dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/animation/animation-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/window.h>
 439 #include <dali/public-api/adaptor-framework/style-change.h>
 440 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 441 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 442 #include <dali/devel-api/adaptor-framework/window-devel.h>
 443
 444 #include <dali/devel-api/images/nine-patch-image.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 454 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 458 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 459 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 460 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 461
 462 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 463 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 464 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 465
 466 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 470
 471 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 472
 473 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 474
 475
 476 // add here SWIG version check
 477
 478 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 479 // disable Swig-dependent warnings
 480
 481 // 'identifier1' has C-linkage specified,
 482 // but returns UDT 'identifier2' which is incompatible with C
 483 #pragma warning(disable: 4190)
 484
 485 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 486 #pragma warning(disable: 4800)
 487
 488 // debug info too long etc etc
 489 #pragma warning(disable: 4786)
 490 #endif
 491
 492
 493 #include <stdexcept>
 494
 495
 496 #include <string>
 497
 498
 499 #include <vector>
 500 #include <algorithm>
 501 #include <stdexcept>
 502
 503
 504 #include <map>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <utility>
 510
 511
 512 typedef float floatp;
 513
 514 SWIGINTERN floatp *new_floatp(){
 515   return new float();
 516 }
 517 SWIGINTERN void delete_floatp(floatp *self){
 518   if (self) delete self;
 519 }
 520 SWIGINTERN void floatp_assign(floatp *self,float value){
 521   *self = value;
 522 }
 523 SWIGINTERN float floatp_value(floatp *self){
 524   return *self;
 525 }
 526 SWIGINTERN float *floatp_cast(floatp *self){
 527   return self;
 528 }
 529 SWIGINTERN floatp *floatp_frompointer(float *t){
 530   return (floatp *) t;
 531 }
 532
 533 typedef int intp;
 534
 535 SWIGINTERN intp *new_intp(){
 536   return new int();
 537 }
 538 SWIGINTERN void delete_intp(intp *self){
 539   if (self) delete self;
 540 }
 541 SWIGINTERN void intp_assign(intp *self,int value){
 542   *self = value;
 543 }
 544 SWIGINTERN int intp_value(intp *self){
 545   return *self;
 546 }
 547 SWIGINTERN int *intp_cast(intp *self){
 548   return self;
 549 }
 550 SWIGINTERN intp *intp_frompointer(int *t){
 551   return (intp *) t;
 552 }
 553
 554 typedef double doublep;
 555
 556 SWIGINTERN doublep *new_doublep(){
 557   return new double();
 558 }
 559 SWIGINTERN void delete_doublep(doublep *self){
 560   if (self) delete self;
 561 }
 562 SWIGINTERN void doublep_assign(doublep *self,double value){
 563   *self = value;
 564 }
 565 SWIGINTERN double doublep_value(doublep *self){
 566   return *self;
 567 }
 568 SWIGINTERN double *doublep_cast(doublep *self){
 569   return self;
 570 }
 571 SWIGINTERN doublep *doublep_frompointer(double *t){
 572   return (doublep *) t;
 573 }
 574
 575 typedef unsigned int uintp;
 576
 577 SWIGINTERN uintp *new_uintp(){
 578   return new unsigned int();
 579 }
 580 SWIGINTERN void delete_uintp(uintp *self){
 581   if (self) delete self;
 582 }
 583 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 584   *self = value;
 585 }
 586 SWIGINTERN unsigned int uintp_value(uintp *self){
 587   return *self;
 588 }
 589 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 590   return self;
 591 }
 592 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 593   return (uintp *) t;
 594 }
 595
 596 typedef unsigned short ushortp;
 597
 598 SWIGINTERN ushortp *new_ushortp(){
 599   return new unsigned short();
 600 }
 601 SWIGINTERN void delete_ushortp(ushortp *self){
 602   if (self) delete self;
 603 }
 604 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 605   *self = value;
 606 }
 607 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 608   return *self;
 609 }
 610 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 611   return self;
 612 }
 613 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 614   return (ushortp *) t;
 615 }
 616
 617 unsigned int int_to_uint(int x) {
 618    return (unsigned int) x;
 619 }
 620
 621
 622 using namespace Dali;
 623 using namespace Dali::Toolkit;
 624
 625 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 626
 627      // C++ code. DALi uses Handle <-> Body design pattern.
 628      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 629      // Handles in DALi can be converted into a boolean type
 630      // to check if the handle has a valid body attached to it.
 631      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 632      if( *self )
 633      {
 634        return true;
 635      }
 636      else
 637      {
 638        return false;
 639      }
 640     }
 641 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 642
 643      // C++ code. Check if two handles reference the same implemtion
 644      if( *self == rhs)
 645      {
 646        return true;
 647      }
 648      else
 649      {
 650        return false;
 651      }
 652     }
 653 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 654      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 655    }
 656 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 657      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 658    }
 659 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 660         std::vector< Dali::TouchPoint >* pv = 0;
 661         if (capacity >= 0) {
 662           pv = new std::vector< Dali::TouchPoint >();
 663           pv->reserve(capacity);
 664        } else {
 665           throw std::out_of_range("capacity");
 666        }
 667        return pv;
 668       }
 669 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 670         if (index>=0 && index<(int)self->size())
 671           return (*self)[index];
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 676         if (index>=0 && index<(int)self->size())
 677           return (*self)[index];
 678         else
 679           throw std::out_of_range("index");
 680       }
 681 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 682         if (index>=0 && index<(int)self->size())
 683           (*self)[index] = val;
 684         else
 685           throw std::out_of_range("index");
 686       }
 687 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 688         self->insert(self->end(), values.begin(), values.end());
 689       }
 690 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 691         if (index < 0)
 692           throw std::out_of_range("index");
 693         if (count < 0)
 694           throw std::out_of_range("count");
 695         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 696           throw std::invalid_argument("invalid range");
 697         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 700         if (index>=0 && index<(int)self->size()+1)
 701           self->insert(self->begin()+index, x);
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 706         if (index>=0 && index<(int)self->size()+1)
 707           self->insert(self->begin()+index, values.begin(), values.end());
 708         else
 709           throw std::out_of_range("index");
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 712         if (index>=0 && index<(int)self->size())
 713           self->erase(self->begin() + index);
 714         else
 715           throw std::out_of_range("index");
 716       }
 717 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 718         if (index < 0)
 719           throw std::out_of_range("index");
 720         if (count < 0)
 721           throw std::out_of_range("count");
 722         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 723           throw std::invalid_argument("invalid range");
 724         self->erase(self->begin()+index, self->begin()+index+count);
 725       }
 726 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 727         if (count < 0)
 728           throw std::out_of_range("count");
 729         return new std::vector< Dali::TouchPoint >(count, value);
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 732         std::reverse(self->begin(), self->end());
 733       }
 734 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 735         if (index < 0)
 736           throw std::out_of_range("index");
 737         if (count < 0)
 738           throw std::out_of_range("count");
 739         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 740           throw std::invalid_argument("invalid range");
 741         std::reverse(self->begin()+index, self->begin()+index+count);
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 744         if (index < 0)
 745           throw std::out_of_range("index");
 746         if (index+values.size() > self->size())
 747           throw std::out_of_range("index");
 748         std::copy(values.begin(), values.end(), self->begin()+index);
 749       }
 750 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 751          return self->Empty();
 752       }
 753 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 754         return self->GetConnectionCount();
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Connect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 760           self->Disconnect( func );
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 763           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 764 /*@SWIG@*/ self->Emit( arg );
 765       }
 766 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767          return self->Empty();
 768       }
 769 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 770         return self->GetConnectionCount();
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Connect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 776           self->Disconnect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 779           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 780 /*@SWIG@*/ self->Emit( arg );
 781       }
 782 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 783          return self->Empty();
 784       }
 785 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 786         return self->GetConnectionCount();
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 789           self->Connect( func );
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 792           self->Disconnect( func );
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 795           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 796 /*@SWIG@*/ self->Emit( arg );
 797       }
 798 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799          return self->Empty();
 800       }
 801 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 802         return self->GetConnectionCount();
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Connect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 808           self->Disconnect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 811           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 812 /*@SWIG@*/ self->Emit( arg );
 813       }
 814 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 815          return self->Empty();
 816       }
 817 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 818         return self->GetConnectionCount();
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Connect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 824           self->Disconnect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 827           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 828 /*@SWIG@*/ self->Emit( arg );
 829       }
 830 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 831          return self->Empty();
 832       }
 833 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 834         return self->GetConnectionCount();
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 837         self->Connect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 840         self->Disconnect( func );
 841       }
 842 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 843         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 844 /*@SWIG@*/ self->Emit( arg1, arg2 );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 847          return self->Empty();
 848       }
 849 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 850         return self->GetConnectionCount();
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 853         self->Connect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 856         self->Disconnect( func );
 857       }
 858 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 859         return self->Emit( arg1, arg2 );
 860       }
 861 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 862          return self->Empty();
 863       }
 864 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 865         return self->GetConnectionCount();
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 868         self->Connect( func );
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 871         self->Disconnect( func );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 874         return self->Emit( arg1, arg2 );
 875       }
 876 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 877          return self->Empty();
 878       }
 879 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 880         return self->GetConnectionCount();
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 883         self->Connect( func );
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 886         self->Disconnect( func );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 889         return self->Emit( arg1, arg2 );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 892          return self->Empty();
 893       }
 894 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 895         return self->GetConnectionCount();
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Connect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 901           self->Disconnect( func );
 902       }
 903 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 904           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg );
 906       }
 907 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 908          return self->Empty();
 909       }
 910 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 911         return self->GetConnectionCount();
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 914           self->Connect( func );
 915       }
 916 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 917           self->Disconnect( func );
 918       }
 919 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 920           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 921 /*@SWIG@*/ self->Emit( arg );
 922       }
 923 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 924          return self->Empty();
 925       }
 926 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 927         return self->GetConnectionCount();
 928       }
 929 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 930           self->Connect( func );
 931       }
 932 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 933           self->Disconnect( func );
 934       }
 935 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 936           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 937 /*@SWIG@*/ self->Emit( arg );
 938       }
 939 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 940          return self->Empty();
 941       }
 942 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 943         return self->GetConnectionCount();
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 946           self->Connect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 949           self->Disconnect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 952           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg );
 954       }
 955 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 956          return self->Empty();
 957       }
 958 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 959         return self->GetConnectionCount();
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 962         self->Connect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 965         self->Disconnect( func );
 966       }
 967 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 968         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg1, arg2 );
 970       }
 971 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 972          return self->Empty();
 973       }
 974 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 975         return self->GetConnectionCount();
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 978         self->Connect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 981         self->Disconnect( func );
 982       }
 983 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 984         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg1, arg2 );
 986       }
 987 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 988          return self->Empty();
 989       }
 990 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 991         return self->GetConnectionCount();
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 994         self->Connect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 997         self->Disconnect( func );
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1000         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1001 /*@SWIG@*/ self->Emit( arg1, arg2 );
1002       }
1003 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1004          return self->Empty();
1005       }
1006 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1007         return self->GetConnectionCount();
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1010           self->Connect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1013           self->Disconnect( func );
1014       }
1015 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1016           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1017 /*@SWIG@*/ self->Emit( arg );
1018       }
1019 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1020          return self->Empty();
1021       }
1022 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1023         return self->GetConnectionCount();
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1026           self->Connect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1029           self->Disconnect( func );
1030       }
1031 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1032           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1033 /*@SWIG@*/ self->Emit( arg );
1034       }
1035 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1036          return self->Empty();
1037       }
1038 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1039         return self->GetConnectionCount();
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1042           return self->Connect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1045           self->Disconnect( func );
1046       }
1047 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1048           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1049 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1050       }
1051
1052   // keep argcs and argv so they're always available to DALi
1053   int argC = 1;
1054   char **argV = NULL;
1055
1056 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1057          return self->Empty();
1058       }
1059 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1060         return self->GetConnectionCount();
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1063           self->Connect( func );
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1066           self->Disconnect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1069           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1070 /*@SWIG@*/ self->Emit( arg );
1071       }
1072 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1073          return self->Empty();
1074       }
1075 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1076         return self->GetConnectionCount();
1077       }
1078 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1079         self->Connect( func );
1080       }
1081 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1082         self->Disconnect( func );
1083       }
1084 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1085         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1086 /*@SWIG@*/ self->Emit( arg1, arg2 );
1087       }
1088 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1089          return self->Empty();
1090       }
1091 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1092         return self->GetConnectionCount();
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1095           self->Connect( func );
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Disconnect( func );
1099       }
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1101           return self->Emit();
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1104          return self->Empty();
1105       }
1106 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1107         return self->GetConnectionCount();
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1110           self->Connect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1113           self->Disconnect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1116           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1117 /*@SWIG@*/ self->Emit( arg );
1118       }
1119 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1120         std::vector< unsigned int >* pv = 0;
1121         if (capacity >= 0) {
1122           pv = new std::vector< unsigned int >();
1123           pv->reserve(capacity);
1124        } else {
1125           throw std::out_of_range("capacity");
1126        }
1127        return pv;
1128       }
1129 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           return (*self)[index];
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1142         if (index>=0 && index<(int)self->size())
1143           (*self)[index] = val;
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1148         self->insert(self->end(), values.begin(), values.end());
1149       }
1150 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (count < 0)
1154           throw std::out_of_range("count");
1155         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1156           throw std::invalid_argument("invalid range");
1157         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1160         if (index>=0 && index<(int)self->size()+1)
1161           self->insert(self->begin()+index, x);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, values.begin(), values.end());
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1172         if (index>=0 && index<(int)self->size())
1173           self->erase(self->begin() + index);
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         self->erase(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         return new std::vector< unsigned int >(count, value);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1192         std::reverse(self->begin(), self->end());
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         std::reverse(self->begin()+index, self->begin()+index+count);
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (index+values.size() > self->size())
1207           throw std::out_of_range("index");
1208         std::copy(values.begin(), values.end(), self->begin()+index);
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1211         return std::find(self->begin(), self->end(), value) != self->end();
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1216         if (it != self->end())
1217           index = (int)(it - self->begin());
1218         return index;
1219       }
1220 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1221         int index = -1;
1222         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1223         if (rit != self->rend())
1224           index = (int)(self->rend() - 1 - rit);
1225         return index;
1226       }
1227 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1228         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1229         if (it != self->end()) {
1230           self->erase(it);
1231           return true;
1232         }
1233         return false;
1234       }
1235 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1236         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1237         if (capacity >= 0) {
1238           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1239           pv->reserve(capacity);
1240        } else {
1241           throw std::out_of_range("capacity");
1242        }
1243        return pv;
1244       }
1245 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1246         if (index>=0 && index<(int)self->size())
1247           return (*self)[index];
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1258         if (index>=0 && index<(int)self->size())
1259           (*self)[index] = val;
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1264         self->insert(self->end(), values.begin(), values.end());
1265       }
1266 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (count < 0)
1270           throw std::out_of_range("count");
1271         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1272           throw std::invalid_argument("invalid range");
1273         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1276         if (index>=0 && index<(int)self->size()+1)
1277           self->insert(self->begin()+index, x);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, values.begin(), values.end());
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1288         if (index>=0 && index<(int)self->size())
1289           self->erase(self->begin() + index);
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         self->erase(self->begin()+index, self->begin()+index+count);
1301       }
1302 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1308         std::reverse(self->begin(), self->end());
1309       }
1310 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (count < 0)
1314           throw std::out_of_range("count");
1315         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1316           throw std::invalid_argument("invalid range");
1317         std::reverse(self->begin()+index, self->begin()+index+count);
1318       }
1319 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (index+values.size() > self->size())
1323           throw std::out_of_range("index");
1324         std::copy(values.begin(), values.end(), self->begin()+index);
1325       }
1326 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1327         std::vector< Dali::Actor >* pv = 0;
1328         if (capacity >= 0) {
1329           pv = new std::vector< Dali::Actor >();
1330           pv->reserve(capacity);
1331        } else {
1332           throw std::out_of_range("capacity");
1333        }
1334        return pv;
1335       }
1336 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           return (*self)[index];
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1349         if (index>=0 && index<(int)self->size())
1350           (*self)[index] = val;
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1355         self->insert(self->end(), values.begin(), values.end());
1356       }
1357 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (count < 0)
1361           throw std::out_of_range("count");
1362         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1363           throw std::invalid_argument("invalid range");
1364         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1367         if (index>=0 && index<(int)self->size()+1)
1368           self->insert(self->begin()+index, x);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, values.begin(), values.end());
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1379         if (index>=0 && index<(int)self->size())
1380           self->erase(self->begin() + index);
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         self->erase(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         return new std::vector< Dali::Actor >(count, value);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1399         std::reverse(self->begin(), self->end());
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (count < 0)
1405           throw std::out_of_range("count");
1406         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1407           throw std::invalid_argument("invalid range");
1408         std::reverse(self->begin()+index, self->begin()+index+count);
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (index+values.size() > self->size())
1414           throw std::out_of_range("index");
1415         std::copy(values.begin(), values.end(), self->begin()+index);
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1424           self->Connect( func );
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1427           self->Disconnect( func );
1428       }
1429 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1430           return self->Emit( arg );
1431       }
1432 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1433          return self->Empty();
1434       }
1435 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1436         return self->GetConnectionCount();
1437       }
1438 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1439         self->Connect( func );
1440       }
1441 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1442         self->Disconnect( func );
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1445         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1446 /*@SWIG@*/ self->Emit( arg1, arg2 );
1447       }
1448 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1449          return self->Empty();
1450       }
1451 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452         return self->GetConnectionCount();
1453       }
1454 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1455         self->Connect( func );
1456       }
1457 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1458         self->Disconnect( func );
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1461         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1462 /*@SWIG@*/ self->Emit( arg1, arg2 );
1463       }
1464 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465          return self->Empty();
1466       }
1467 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468         return self->GetConnectionCount();
1469       }
1470 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1471         self->Connect( func );
1472       }
1473 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1474         self->Disconnect( func );
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1477         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1478 /*@SWIG@*/ self->Emit( arg1, arg2 );
1479       }
1480 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1481          return self->Empty();
1482       }
1483 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1484         return self->GetConnectionCount();
1485       }
1486 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1487         self->Connect( func );
1488       }
1489 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1490         self->Disconnect( func );
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1493         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1494 /*@SWIG@*/ self->Emit( arg1, arg2 );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497          return self->Empty();
1498       }
1499 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500         return self->GetConnectionCount();
1501       }
1502 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1503           self->Connect( func );
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1506           self->Disconnect( func );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1509           return self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1518           self->Connect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1534           return self->Connect( func );
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1537           self->Disconnect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1550           self->Connect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1553           self->Disconnect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1556           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1557 /*@SWIG@*/ self->Emit( arg );
1558       }
1559 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1560          return self->Empty();
1561       }
1562 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1563         return self->GetConnectionCount();
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1566           return self->Connect( func );
1567       }
1568 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1569           self->Disconnect( func );
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1572           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1573 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1574       }
1575 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1576          return self->Empty();
1577       }
1578 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1579         return self->GetConnectionCount();
1580       }
1581 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1582           self->Connect( func );
1583       }
1584 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1585           self->Disconnect( func );
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1588           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1589 /*@SWIG@*/ self->Emit( arg );
1590       }
1591 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1592          return self->Empty();
1593       }
1594 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595         return self->GetConnectionCount();
1596       }
1597 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1598           self->Connect( func );
1599       }
1600 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1601           self->Disconnect( func );
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1604           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1605 /*@SWIG@*/ self->Emit( arg );
1606       }
1607 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1608          return self->Empty();
1609       }
1610 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1611         return self->GetConnectionCount();
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1614           self->Connect( func );
1615       }
1616 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1617           self->Disconnect( func );
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1620           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1621 /*@SWIG@*/ self->Emit( arg );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1630           self->Connect( func );
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1640          return self->Empty();
1641       }
1642 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1643         return self->GetConnectionCount();
1644       }
1645 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1646         self->Connect( func );
1647       }
1648 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1649         self->Disconnect( func );
1650       }
1651 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1652         return self->Emit( arg1, arg2 );
1653       }
1654 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1655          return self->Empty();
1656       }
1657 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1658         return self->GetConnectionCount();
1659       }
1660 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1661           self->Connect( func );
1662       }
1663 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1664           self->Disconnect( func );
1665       }
1666 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1667           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1668 /*@SWIG@*/ self->Emit( arg );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1671          return self->Empty();
1672       }
1673 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1674         return self->GetConnectionCount();
1675       }
1676 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1677           self->Connect( func );
1678       }
1679 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1680           self->Disconnect( func );
1681       }
1682 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1683           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1684 /*@SWIG@*/ self->Emit( arg );
1685       }
1686 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1687          return self->Empty();
1688       }
1689 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1690         return self->GetConnectionCount();
1691       }
1692 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1693         self->Connect( func );
1694       }
1695 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1696         self->Disconnect( func );
1697       }
1698 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1699         return self->Emit( arg1, arg2 );
1700       }
1701 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1702          return self->Empty();
1703       }
1704 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1705         return self->GetConnectionCount();
1706       }
1707 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1708         self->Connect( func );
1709       }
1710 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1711         self->Disconnect( func );
1712       }
1713 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1714         return self->Emit( arg1, arg2 );
1715       }
1716
1717
1718 /* ---------------------------------------------------
1719  * C++ director class methods
1720  * --------------------------------------------------- */
1721
1722 #include "dali_wrap.h"
1723
1724 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1725   swig_init_callbacks();
1726 }
1727
1728 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1729
1730 }
1731
1732
1733 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1734   int jdepth  ;
1735
1736   if (!swig_callbackOnStageConnection) {
1737     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1738     return;
1739   } else {
1740     jdepth = depth;
1741     swig_callbackOnStageConnection(jdepth);
1742   }
1743 }
1744
1745 void SwigDirector_ViewImpl::OnStageDisconnection() {
1746   if (!swig_callbackOnStageDisconnection) {
1747     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1748     return;
1749   } else {
1750     swig_callbackOnStageDisconnection();
1751   }
1752 }
1753
1754 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1755   void * jchild = 0 ;
1756
1757   if (!swig_callbackOnChildAdd) {
1758     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1759     return;
1760   } else {
1761     jchild = (Dali::Actor *) &child;
1762     swig_callbackOnChildAdd(jchild);
1763   }
1764 }
1765
1766 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1767   void * jchild = 0 ;
1768
1769   if (!swig_callbackOnChildRemove) {
1770     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1771     return;
1772   } else {
1773     jchild = (Dali::Actor *) &child;
1774     swig_callbackOnChildRemove(jchild);
1775   }
1776 }
1777
1778 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1779   int jindex  ;
1780   void * jpropertyValue  ;
1781
1782   if (!swig_callbackOnPropertySet) {
1783     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1784     return;
1785   } else {
1786     jindex = index;
1787     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1788     swig_callbackOnPropertySet(jindex, jpropertyValue);
1789   }
1790 }
1791
1792 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1793   void * jtargetSize = 0 ;
1794
1795   if (!swig_callbackOnSizeSet) {
1796     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1797     return;
1798   } else {
1799     jtargetSize = (Dali::Vector3 *) &targetSize;
1800     swig_callbackOnSizeSet(jtargetSize);
1801   }
1802 }
1803
1804 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1805   void * janimation = 0 ;
1806   void * jtargetSize = 0 ;
1807
1808   if (!swig_callbackOnSizeAnimation) {
1809     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1810     return;
1811   } else {
1812     janimation = (Dali::Animation *) &animation;
1813     jtargetSize = (Dali::Vector3 *) &targetSize;
1814     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1815   }
1816 }
1817
1818 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1819   bool c_result = SwigValueInit< bool >() ;
1820   unsigned int jresult = 0 ;
1821   void * jarg0 = 0 ;
1822
1823   if (!swig_callbackOnTouchEvent) {
1824     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1825   } else {
1826     jarg0 = (Dali::TouchEvent *) &event;
1827     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1828     c_result = jresult ? true : false;
1829   }
1830   return c_result;
1831 }
1832
1833 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1834   bool c_result = SwigValueInit< bool >() ;
1835   unsigned int jresult = 0 ;
1836   void * jarg0 = 0 ;
1837
1838   if (!swig_callbackOnHoverEvent) {
1839     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1840   } else {
1841     jarg0 = (Dali::HoverEvent *) &event;
1842     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1843     c_result = jresult ? true : false;
1844   }
1845   return c_result;
1846 }
1847
1848 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1849   bool c_result = SwigValueInit< bool >() ;
1850   unsigned int jresult = 0 ;
1851   void * jarg0 = 0 ;
1852
1853   if (!swig_callbackOnKeyEvent) {
1854     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1855   } else {
1856     jarg0 = (Dali::KeyEvent *) &event;
1857     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1858     c_result = jresult ? true : false;
1859   }
1860   return c_result;
1861 }
1862
1863 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1864   bool c_result = SwigValueInit< bool >() ;
1865   unsigned int jresult = 0 ;
1866   void * jarg0 = 0 ;
1867
1868   if (!swig_callbackOnWheelEvent) {
1869     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1870   } else {
1871     jarg0 = (Dali::WheelEvent *) &event;
1872     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1873     c_result = jresult ? true : false;
1874   }
1875   return c_result;
1876 }
1877
1878 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1879   void * jsize = 0 ;
1880   void * jcontainer = 0 ;
1881
1882   if (!swig_callbackOnRelayout) {
1883     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1884     return;
1885   } else {
1886     jsize = (Dali::Vector2 *) &size;
1887     jcontainer = (Dali::RelayoutContainer *) &container;
1888     swig_callbackOnRelayout(jsize, jcontainer);
1889   }
1890 }
1891
1892 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1893   int jpolicy  ;
1894   int jdimension  ;
1895
1896   if (!swig_callbackOnSetResizePolicy) {
1897     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1898     return;
1899   } else {
1900     jpolicy = (int)policy;
1901     jdimension = (int)dimension;
1902     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1903   }
1904 }
1905
1906 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1907   Dali::Vector3 c_result ;
1908   void * jresult = 0 ;
1909
1910   if (!swig_callbackGetNaturalSize) {
1911     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1912   } else {
1913     jresult = (void *) swig_callbackGetNaturalSize();
1914     if (!jresult) {
1915       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1916       return c_result;
1917     }
1918     c_result = *(Dali::Vector3 *)jresult;
1919   }
1920   return c_result;
1921 }
1922
1923 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1924   float c_result = SwigValueInit< float >() ;
1925   float jresult = 0 ;
1926   void * jchild = 0 ;
1927   int jdimension  ;
1928
1929   if (!swig_callbackCalculateChildSize) {
1930     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1931   } else {
1932     jchild = (Dali::Actor *) &child;
1933     jdimension = (int)dimension;
1934     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1935     c_result = (float)jresult;
1936   }
1937   return c_result;
1938 }
1939
1940 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1941   float c_result = SwigValueInit< float >() ;
1942   float jresult = 0 ;
1943   float jwidth  ;
1944
1945   if (!swig_callbackGetHeightForWidth) {
1946     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1947   } else {
1948     jwidth = width;
1949     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1950     c_result = (float)jresult;
1951   }
1952   return c_result;
1953 }
1954
1955 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1956   float c_result = SwigValueInit< float >() ;
1957   float jresult = 0 ;
1958   float jheight  ;
1959
1960   if (!swig_callbackGetWidthForHeight) {
1961     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1962   } else {
1963     jheight = height;
1964     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1965     c_result = (float)jresult;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   int jdimension  ;
1974
1975   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1976     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1977   } else {
1978     jdimension = (int)dimension;
1979     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1986   int jdimension  ;
1987
1988   if (!swig_callbackOnCalculateRelayoutSize) {
1989     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1990     return;
1991   } else {
1992     jdimension = (int)dimension;
1993     swig_callbackOnCalculateRelayoutSize(jdimension);
1994   }
1995 }
1996
1997 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1998   float jsize  ;
1999   int jdimension  ;
2000
2001   if (!swig_callbackOnLayoutNegotiated) {
2002     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2003     return;
2004   } else {
2005     jsize = size;
2006     jdimension = (int)dimension;
2007     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2008   }
2009 }
2010
2011 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2012   return Dali::CustomActorImpl::GetExtension();
2013 }
2014
2015 void SwigDirector_ViewImpl::OnInitialize() {
2016   if (!swig_callbackOnInitialize) {
2017     Dali::Toolkit::Internal::Control::OnInitialize();
2018     return;
2019   } else {
2020     swig_callbackOnInitialize();
2021   }
2022 }
2023
2024 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2025   void * jchild = 0 ;
2026
2027   if (!swig_callbackOnControlChildAdd) {
2028     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2029     return;
2030   } else {
2031     jchild = (Dali::Actor *) &child;
2032     swig_callbackOnControlChildAdd(jchild);
2033   }
2034 }
2035
2036 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2037   void * jchild = 0 ;
2038
2039   if (!swig_callbackOnControlChildRemove) {
2040     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2041     return;
2042   } else {
2043     jchild = (Dali::Actor *) &child;
2044     swig_callbackOnControlChildRemove(jchild);
2045   }
2046 }
2047
2048 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2049   void * jstyleManager  ;
2050   int jchange  ;
2051
2052   if (!swig_callbackOnStyleChange) {
2053     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2054     return;
2055   } else {
2056     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2057     jchange = (int)change;
2058     swig_callbackOnStyleChange(jstyleManager, jchange);
2059   }
2060 }
2061
2062 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2063   bool c_result = SwigValueInit< bool >() ;
2064   unsigned int jresult = 0 ;
2065
2066   if (!swig_callbackOnAccessibilityActivated) {
2067     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2068   } else {
2069     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2070     c_result = jresult ? true : false;
2071   }
2072   return c_result;
2073 }
2074
2075 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2076   bool c_result = SwigValueInit< bool >() ;
2077   unsigned int jresult = 0 ;
2078   void * jgesture  ;
2079
2080   if (!swig_callbackOnAccessibilityPan) {
2081     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2082   } else {
2083     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2084     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2085     c_result = jresult ? true : false;
2086   }
2087   return c_result;
2088 }
2089
2090 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2091   bool c_result = SwigValueInit< bool >() ;
2092   unsigned int jresult = 0 ;
2093   void * jtouchEvent = 0 ;
2094
2095   if (!swig_callbackOnAccessibilityTouch) {
2096     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2097   } else {
2098     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2099     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2100     c_result = jresult ? true : false;
2101   }
2102   return c_result;
2103 }
2104
2105 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2106   bool c_result = SwigValueInit< bool >() ;
2107   unsigned int jresult = 0 ;
2108   unsigned int jisIncrease  ;
2109
2110   if (!swig_callbackOnAccessibilityValueChange) {
2111     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2112   } else {
2113     jisIncrease = isIncrease;
2114     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2115     c_result = jresult ? true : false;
2116   }
2117   return c_result;
2118 }
2119
2120 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2121   bool c_result = SwigValueInit< bool >() ;
2122   unsigned int jresult = 0 ;
2123
2124   if (!swig_callbackOnAccessibilityZoom) {
2125     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2126   } else {
2127     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2128     c_result = jresult ? true : false;
2129   }
2130   return c_result;
2131 }
2132
2133 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2134   if (!swig_callbackOnKeyInputFocusGained) {
2135     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2136     return;
2137   } else {
2138     swig_callbackOnKeyInputFocusGained();
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2143   if (!swig_callbackOnKeyInputFocusLost) {
2144     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2145     return;
2146   } else {
2147     swig_callbackOnKeyInputFocusLost();
2148   }
2149 }
2150
2151 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2152   Dali::Actor c_result ;
2153   void * jresult = 0 ;
2154   void * jcurrentFocusedActor  ;
2155   int jdirection  ;
2156   unsigned int jloopEnabled  ;
2157
2158   if (!swig_callbackGetNextKeyboardFocusableActor) {
2159     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2160   } else {
2161     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2162     jdirection = (int)direction;
2163     jloopEnabled = loopEnabled;
2164     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2165     if (!jresult) {
2166       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2167       return c_result;
2168     }
2169     c_result = *(Dali::Actor *)jresult;
2170   }
2171   return c_result;
2172 }
2173
2174 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2175   void * jcommitedFocusableActor  ;
2176
2177   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2178     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2179     return;
2180   } else {
2181     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2182     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2183   }
2184 }
2185
2186 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2187   bool c_result = SwigValueInit< bool >() ;
2188   unsigned int jresult = 0 ;
2189
2190   if (!swig_callbackOnKeyboardEnter) {
2191     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2192   } else {
2193     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2200   void * jpinch = 0 ;
2201
2202   if (!swig_callbackOnPinch) {
2203     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2204     return;
2205   } else {
2206     jpinch = (Dali::PinchGesture *) &pinch;
2207     swig_callbackOnPinch(jpinch);
2208   }
2209 }
2210
2211 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2212   void * jpan = 0 ;
2213
2214   if (!swig_callbackOnPan) {
2215     Dali::Toolkit::Internal::Control::OnPan(pan);
2216     return;
2217   } else {
2218     jpan = (Dali::PanGesture *) &pan;
2219     swig_callbackOnPan(jpan);
2220   }
2221 }
2222
2223 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2224   void * jtap = 0 ;
2225
2226   if (!swig_callbackOnTap) {
2227     Dali::Toolkit::Internal::Control::OnTap(tap);
2228     return;
2229   } else {
2230     jtap = (Dali::TapGesture *) &tap;
2231     swig_callbackOnTap(jtap);
2232   }
2233 }
2234
2235 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2236   void * jlongPress = 0 ;
2237
2238   if (!swig_callbackOnLongPress) {
2239     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2240     return;
2241   } else {
2242     jlongPress = (Dali::LongPressGesture *) &longPress;
2243     swig_callbackOnLongPress(jlongPress);
2244   }
2245 }
2246
2247 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2248   void * jslotObserver = 0 ;
2249   void * jcallback = 0 ;
2250
2251   if (!swig_callbackSignalConnected) {
2252     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2253     return;
2254   } else {
2255     jslotObserver = (void *) slotObserver;
2256     jcallback = (void *) callback;
2257     swig_callbackSignalConnected(jslotObserver, jcallback);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2262   void * jslotObserver = 0 ;
2263   void * jcallback = 0 ;
2264
2265   if (!swig_callbackSignalDisconnected) {
2266     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2267     return;
2268   } else {
2269     jslotObserver = (void *) slotObserver;
2270     jcallback = (void *) callback;
2271     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2272   }
2273 }
2274
2275 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2276   return Dali::Toolkit::Internal::Control::GetControlExtension();
2277 }
2278
2279 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2280   swig_callbackOnStageConnection = callbackOnStageConnection;
2281   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2282   swig_callbackOnChildAdd = callbackOnChildAdd;
2283   swig_callbackOnChildRemove = callbackOnChildRemove;
2284   swig_callbackOnPropertySet = callbackOnPropertySet;
2285   swig_callbackOnSizeSet = callbackOnSizeSet;
2286   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2287   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2288   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2289   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2290   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2291   swig_callbackOnRelayout = callbackOnRelayout;
2292   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2293   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2294   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2295   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2296   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2297   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2298   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2299   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2300   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2301   swig_callbackOnInitialize = callbackOnInitialize;
2302   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2303   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2304   swig_callbackOnStyleChange = callbackOnStyleChange;
2305   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2306   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2307   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2308   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2309   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2310   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2311   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2312   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2313   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2314   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2315   swig_callbackOnPinch = callbackOnPinch;
2316   swig_callbackOnPan = callbackOnPan;
2317   swig_callbackOnTap = callbackOnTap;
2318   swig_callbackOnLongPress = callbackOnLongPress;
2319   swig_callbackSignalConnected = callbackSignalConnected;
2320   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2321 }
2322
2323 void SwigDirector_ViewImpl::swig_init_callbacks() {
2324   swig_callbackOnStageConnection = 0;
2325   swig_callbackOnStageDisconnection = 0;
2326   swig_callbackOnChildAdd = 0;
2327   swig_callbackOnChildRemove = 0;
2328   swig_callbackOnPropertySet = 0;
2329   swig_callbackOnSizeSet = 0;
2330   swig_callbackOnSizeAnimation = 0;
2331   swig_callbackOnTouchEvent = 0;
2332   swig_callbackOnHoverEvent = 0;
2333   swig_callbackOnKeyEvent = 0;
2334   swig_callbackOnWheelEvent = 0;
2335   swig_callbackOnRelayout = 0;
2336   swig_callbackOnSetResizePolicy = 0;
2337   swig_callbackGetNaturalSize = 0;
2338   swig_callbackCalculateChildSize = 0;
2339   swig_callbackGetHeightForWidth = 0;
2340   swig_callbackGetWidthForHeight = 0;
2341   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2342   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2343   swig_callbackOnCalculateRelayoutSize = 0;
2344   swig_callbackOnLayoutNegotiated = 0;
2345   swig_callbackOnInitialize = 0;
2346   swig_callbackOnControlChildAdd = 0;
2347   swig_callbackOnControlChildRemove = 0;
2348   swig_callbackOnStyleChange = 0;
2349   swig_callbackOnAccessibilityActivated = 0;
2350   swig_callbackOnAccessibilityPan = 0;
2351   swig_callbackOnAccessibilityTouch = 0;
2352   swig_callbackOnAccessibilityValueChange = 0;
2353   swig_callbackOnAccessibilityZoom = 0;
2354   swig_callbackOnKeyInputFocusGained = 0;
2355   swig_callbackOnKeyInputFocusLost = 0;
2356   swig_callbackGetNextKeyboardFocusableActor = 0;
2357   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2358   swig_callbackOnKeyboardEnter = 0;
2359   swig_callbackOnPinch = 0;
2360   swig_callbackOnPan = 0;
2361   swig_callbackOnTap = 0;
2362   swig_callbackOnLongPress = 0;
2363   swig_callbackSignalConnected = 0;
2364   swig_callbackSignalDisconnected = 0;
2365 }
2366
2367 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2368   swig_init_callbacks();
2369 }
2370
2371 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2372
2373 }
2374
2375
2376 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2377   unsigned int c_result = SwigValueInit< unsigned int >() ;
2378   unsigned int jresult = 0 ;
2379
2380   if (!swig_callbackGetNumberOfItems) {
2381     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2382   } else {
2383     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2384     c_result = (unsigned int)jresult;
2385   }
2386   return c_result;
2387 }
2388
2389 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2390   Dali::Actor c_result ;
2391   void * jresult = 0 ;
2392   unsigned int jitemId  ;
2393
2394   if (!swig_callbackNewItem) {
2395     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2396   } else {
2397     jitemId = itemId;
2398     jresult = (void *) swig_callbackNewItem(jitemId);
2399     if (!jresult) {
2400       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2401       return c_result;
2402     }
2403     c_result = *(Dali::Actor *)jresult;
2404   }
2405   return c_result;
2406 }
2407
2408 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2409   unsigned int jitemId  ;
2410   void * jactor  ;
2411
2412   if (!swig_callbackItemReleased) {
2413     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2414     return;
2415   } else {
2416     jitemId = itemId;
2417     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2418     swig_callbackItemReleased(jitemId, jactor);
2419   }
2420 }
2421
2422 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2423   return Dali::Toolkit::ItemFactory::GetExtension();
2424 }
2425
2426 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2427   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2428   swig_callbackNewItem = callbackNewItem;
2429   swig_callbackItemReleased = callbackItemReleased;
2430 }
2431
2432 void SwigDirector_ItemFactory::swig_init_callbacks() {
2433   swig_callbackGetNumberOfItems = 0;
2434   swig_callbackNewItem = 0;
2435   swig_callbackItemReleased = 0;
2436 }
2437
2438 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2439   swig_init_callbacks();
2440 }
2441
2442 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2443
2444 }
2445
2446
2447 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2448   Dali::Actor c_result ;
2449   void * jresult = 0 ;
2450   void * jcurrent  ;
2451   void * jproposed  ;
2452   int jdirection  ;
2453
2454   if (!swig_callbackGetNextFocusableActor) {
2455     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2456   } else {
2457     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2458     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2459     jdirection = (int)direction;
2460     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2461     if (!jresult) {
2462       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2463       return c_result;
2464     }
2465     c_result = *(Dali::Actor *)jresult;
2466   }
2467   return c_result;
2468 }
2469
2470 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2471   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2472 }
2473
2474 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2475   swig_callbackGetNextFocusableActor = 0;
2476 }
2477
2478
2479 #ifdef __cplusplus
2480 extern "C" {
2481 #endif
2482
2483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2484   void * jresult ;
2485   floatp *result = 0 ;
2486
2487   {
2488     try {
2489       result = (floatp *)new_floatp();
2490     } catch (std::out_of_range& e) {
2491       {
2492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2493       };
2494     } catch (std::exception& e) {
2495       {
2496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2497       };
2498     } catch (...) {
2499       {
2500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2501       };
2502     }
2503   }
2504   jresult = (void *)result;
2505   return jresult;
2506 }
2507
2508
2509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2510   floatp *arg1 = (floatp *) 0 ;
2511
2512   arg1 = (floatp *)jarg1;
2513   {
2514     try {
2515       delete_floatp(arg1);
2516     } catch (std::out_of_range& e) {
2517       {
2518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2519       };
2520     } catch (std::exception& e) {
2521       {
2522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2523       };
2524     } catch (...) {
2525       {
2526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2527       };
2528     }
2529   }
2530 }
2531
2532
2533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2534   floatp *arg1 = (floatp *) 0 ;
2535   float arg2 ;
2536
2537   arg1 = (floatp *)jarg1;
2538   arg2 = (float)jarg2;
2539   {
2540     try {
2541       floatp_assign(arg1,arg2);
2542     } catch (std::out_of_range& e) {
2543       {
2544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2545       };
2546     } catch (std::exception& e) {
2547       {
2548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2549       };
2550     } catch (...) {
2551       {
2552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2553       };
2554     }
2555   }
2556 }
2557
2558
2559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2560   float jresult ;
2561   floatp *arg1 = (floatp *) 0 ;
2562   float result;
2563
2564   arg1 = (floatp *)jarg1;
2565   {
2566     try {
2567       result = (float)floatp_value(arg1);
2568     } catch (std::out_of_range& e) {
2569       {
2570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2571       };
2572     } catch (std::exception& e) {
2573       {
2574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2575       };
2576     } catch (...) {
2577       {
2578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2579       };
2580     }
2581   }
2582   jresult = result;
2583   return jresult;
2584 }
2585
2586
2587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2588   void * jresult ;
2589   floatp *arg1 = (floatp *) 0 ;
2590   float *result = 0 ;
2591
2592   arg1 = (floatp *)jarg1;
2593   {
2594     try {
2595       result = (float *)floatp_cast(arg1);
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (...) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2607       };
2608     }
2609   }
2610   jresult = (void *)result;
2611   return jresult;
2612 }
2613
2614
2615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2616   void * jresult ;
2617   float *arg1 = (float *) 0 ;
2618   floatp *result = 0 ;
2619
2620   arg1 = (float *)jarg1;
2621   {
2622     try {
2623       result = (floatp *)floatp_frompointer(arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (...) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2635       };
2636     }
2637   }
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2644   void * jresult ;
2645   intp *result = 0 ;
2646
2647   {
2648     try {
2649       result = (intp *)new_intp();
2650     } catch (std::out_of_range& e) {
2651       {
2652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2653       };
2654     } catch (std::exception& e) {
2655       {
2656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2657       };
2658     } catch (...) {
2659       {
2660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2661       };
2662     }
2663   }
2664   jresult = (void *)result;
2665   return jresult;
2666 }
2667
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2670   intp *arg1 = (intp *) 0 ;
2671
2672   arg1 = (intp *)jarg1;
2673   {
2674     try {
2675       delete_intp(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (...) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2687       };
2688     }
2689   }
2690 }
2691
2692
2693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2694   intp *arg1 = (intp *) 0 ;
2695   int arg2 ;
2696
2697   arg1 = (intp *)jarg1;
2698   arg2 = (int)jarg2;
2699   {
2700     try {
2701       intp_assign(arg1,arg2);
2702     } catch (std::out_of_range& e) {
2703       {
2704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2705       };
2706     } catch (std::exception& e) {
2707       {
2708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2709       };
2710     } catch (...) {
2711       {
2712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2713       };
2714     }
2715   }
2716 }
2717
2718
2719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2720   int jresult ;
2721   intp *arg1 = (intp *) 0 ;
2722   int result;
2723
2724   arg1 = (intp *)jarg1;
2725   {
2726     try {
2727       result = (int)intp_value(arg1);
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (...) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2739       };
2740     }
2741   }
2742   jresult = result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2748   void * jresult ;
2749   intp *arg1 = (intp *) 0 ;
2750   int *result = 0 ;
2751
2752   arg1 = (intp *)jarg1;
2753   {
2754     try {
2755       result = (int *)intp_cast(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (...) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2767       };
2768     }
2769   }
2770   jresult = (void *)result;
2771   return jresult;
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2776   void * jresult ;
2777   int *arg1 = (int *) 0 ;
2778   intp *result = 0 ;
2779
2780   arg1 = (int *)jarg1;
2781   {
2782     try {
2783       result = (intp *)intp_frompointer(arg1);
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (...) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2795       };
2796     }
2797   }
2798   jresult = (void *)result;
2799   return jresult;
2800 }
2801
2802
2803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2804   void * jresult ;
2805   doublep *result = 0 ;
2806
2807   {
2808     try {
2809       result = (doublep *)new_doublep();
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2817       };
2818     } catch (...) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2821       };
2822     }
2823   }
2824   jresult = (void *)result;
2825   return jresult;
2826 }
2827
2828
2829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2830   doublep *arg1 = (doublep *) 0 ;
2831
2832   arg1 = (doublep *)jarg1;
2833   {
2834     try {
2835       delete_doublep(arg1);
2836     } catch (std::out_of_range& e) {
2837       {
2838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2839       };
2840     } catch (std::exception& e) {
2841       {
2842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (...) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2847       };
2848     }
2849   }
2850 }
2851
2852
2853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2854   doublep *arg1 = (doublep *) 0 ;
2855   double arg2 ;
2856
2857   arg1 = (doublep *)jarg1;
2858   arg2 = (double)jarg2;
2859   {
2860     try {
2861       doublep_assign(arg1,arg2);
2862     } catch (std::out_of_range& e) {
2863       {
2864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2865       };
2866     } catch (std::exception& e) {
2867       {
2868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2869       };
2870     } catch (...) {
2871       {
2872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2873       };
2874     }
2875   }
2876 }
2877
2878
2879 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2880   double jresult ;
2881   doublep *arg1 = (doublep *) 0 ;
2882   double result;
2883
2884   arg1 = (doublep *)jarg1;
2885   {
2886     try {
2887       result = (double)doublep_value(arg1);
2888     } catch (std::out_of_range& e) {
2889       {
2890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2891       };
2892     } catch (std::exception& e) {
2893       {
2894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2895       };
2896     } catch (...) {
2897       {
2898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2899       };
2900     }
2901   }
2902   jresult = result;
2903   return jresult;
2904 }
2905
2906
2907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2908   void * jresult ;
2909   doublep *arg1 = (doublep *) 0 ;
2910   double *result = 0 ;
2911
2912   arg1 = (doublep *)jarg1;
2913   {
2914     try {
2915       result = (double *)doublep_cast(arg1);
2916     } catch (std::out_of_range& e) {
2917       {
2918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2919       };
2920     } catch (std::exception& e) {
2921       {
2922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2923       };
2924     } catch (...) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2927       };
2928     }
2929   }
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2936   void * jresult ;
2937   double *arg1 = (double *) 0 ;
2938   doublep *result = 0 ;
2939
2940   arg1 = (double *)jarg1;
2941   {
2942     try {
2943       result = (doublep *)doublep_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (...) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2955       };
2956     }
2957   }
2958   jresult = (void *)result;
2959   return jresult;
2960 }
2961
2962
2963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2964   void * jresult ;
2965   uintp *result = 0 ;
2966
2967   {
2968     try {
2969       result = (uintp *)new_uintp();
2970     } catch (std::out_of_range& e) {
2971       {
2972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2973       };
2974     } catch (std::exception& e) {
2975       {
2976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (...) {
2979       {
2980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2981       };
2982     }
2983   }
2984   jresult = (void *)result;
2985   return jresult;
2986 }
2987
2988
2989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2990   uintp *arg1 = (uintp *) 0 ;
2991
2992   arg1 = (uintp *)jarg1;
2993   {
2994     try {
2995       delete_uintp(arg1);
2996     } catch (std::out_of_range& e) {
2997       {
2998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (std::exception& e) {
3001       {
3002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010 }
3011
3012
3013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3014   uintp *arg1 = (uintp *) 0 ;
3015   unsigned int arg2 ;
3016
3017   arg1 = (uintp *)jarg1;
3018   arg2 = (unsigned int)jarg2;
3019   {
3020     try {
3021       uintp_assign(arg1,arg2);
3022     } catch (std::out_of_range& e) {
3023       {
3024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3025       };
3026     } catch (std::exception& e) {
3027       {
3028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3029       };
3030     } catch (...) {
3031       {
3032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3033       };
3034     }
3035   }
3036 }
3037
3038
3039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3040   unsigned int jresult ;
3041   uintp *arg1 = (uintp *) 0 ;
3042   unsigned int result;
3043
3044   arg1 = (uintp *)jarg1;
3045   {
3046     try {
3047       result = (unsigned int)uintp_value(arg1);
3048     } catch (std::out_of_range& e) {
3049       {
3050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3051       };
3052     } catch (std::exception& e) {
3053       {
3054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3059       };
3060     }
3061   }
3062   jresult = result;
3063   return jresult;
3064 }
3065
3066
3067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3068   void * jresult ;
3069   uintp *arg1 = (uintp *) 0 ;
3070   unsigned int *result = 0 ;
3071
3072   arg1 = (uintp *)jarg1;
3073   {
3074     try {
3075       result = (unsigned int *)uintp_cast(arg1);
3076     } catch (std::out_of_range& e) {
3077       {
3078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3079       };
3080     } catch (std::exception& e) {
3081       {
3082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3083       };
3084     } catch (...) {
3085       {
3086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3087       };
3088     }
3089   }
3090   jresult = (void *)result;
3091   return jresult;
3092 }
3093
3094
3095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3096   void * jresult ;
3097   unsigned int *arg1 = (unsigned int *) 0 ;
3098   uintp *result = 0 ;
3099
3100   arg1 = (unsigned int *)jarg1;
3101   {
3102     try {
3103       result = (uintp *)uintp_frompointer(arg1);
3104     } catch (std::out_of_range& e) {
3105       {
3106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (std::exception& e) {
3109       {
3110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118   jresult = (void *)result;
3119   return jresult;
3120 }
3121
3122
3123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3124   void * jresult ;
3125   ushortp *result = 0 ;
3126
3127   {
3128     try {
3129       result = (ushortp *)new_ushortp();
3130     } catch (std::out_of_range& e) {
3131       {
3132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (std::exception& e) {
3135       {
3136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (...) {
3139       {
3140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3141       };
3142     }
3143   }
3144   jresult = (void *)result;
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3150   ushortp *arg1 = (ushortp *) 0 ;
3151
3152   arg1 = (ushortp *)jarg1;
3153   {
3154     try {
3155       delete_ushortp(arg1);
3156     } catch (std::out_of_range& e) {
3157       {
3158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3159       };
3160     } catch (std::exception& e) {
3161       {
3162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3163       };
3164     } catch (...) {
3165       {
3166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3167       };
3168     }
3169   }
3170 }
3171
3172
3173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3174   ushortp *arg1 = (ushortp *) 0 ;
3175   unsigned short arg2 ;
3176
3177   arg1 = (ushortp *)jarg1;
3178   arg2 = (unsigned short)jarg2;
3179   {
3180     try {
3181       ushortp_assign(arg1,arg2);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (...) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3193       };
3194     }
3195   }
3196 }
3197
3198
3199 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3200   unsigned short jresult ;
3201   ushortp *arg1 = (ushortp *) 0 ;
3202   unsigned short result;
3203
3204   arg1 = (ushortp *)jarg1;
3205   {
3206     try {
3207       result = (unsigned short)ushortp_value(arg1);
3208     } catch (std::out_of_range& e) {
3209       {
3210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3211       };
3212     } catch (std::exception& e) {
3213       {
3214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (...) {
3217       {
3218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3219       };
3220     }
3221   }
3222   jresult = result;
3223   return jresult;
3224 }
3225
3226
3227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3228   void * jresult ;
3229   ushortp *arg1 = (ushortp *) 0 ;
3230   unsigned short *result = 0 ;
3231
3232   arg1 = (ushortp *)jarg1;
3233   {
3234     try {
3235       result = (unsigned short *)ushortp_cast(arg1);
3236     } catch (std::out_of_range& e) {
3237       {
3238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3239       };
3240     } catch (std::exception& e) {
3241       {
3242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3243       };
3244     } catch (...) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3247       };
3248     }
3249   }
3250   jresult = (void *)result;
3251   return jresult;
3252 }
3253
3254
3255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3256   void * jresult ;
3257   unsigned short *arg1 = (unsigned short *) 0 ;
3258   ushortp *result = 0 ;
3259
3260   arg1 = (unsigned short *)jarg1;
3261   {
3262     try {
3263       result = (ushortp *)ushortp_frompointer(arg1);
3264     } catch (std::out_of_range& e) {
3265       {
3266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (std::exception& e) {
3269       {
3270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278   jresult = (void *)result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3284   unsigned int jresult ;
3285   int arg1 ;
3286   unsigned int result;
3287
3288   arg1 = (int)jarg1;
3289   {
3290     try {
3291       result = (unsigned int)int_to_uint(arg1);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3312   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3313
3314   arg1 = (Dali::RefObject *)jarg1;
3315   {
3316     try {
3317       (arg1)->Reference();
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (...) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3329       };
3330     }
3331   }
3332 }
3333
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3336   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3337
3338   arg1 = (Dali::RefObject *)jarg1;
3339   {
3340     try {
3341       (arg1)->Unreference();
3342     } catch (std::out_of_range& e) {
3343       {
3344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (std::exception& e) {
3347       {
3348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3349       };
3350     } catch (...) {
3351       {
3352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3353       };
3354     }
3355   }
3356 }
3357
3358
3359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3360   int jresult ;
3361   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3362   int result;
3363
3364   arg1 = (Dali::RefObject *)jarg1;
3365   {
3366     try {
3367       result = (int)(arg1)->ReferenceCount();
3368     } catch (std::out_of_range& e) {
3369       {
3370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3371       };
3372     } catch (std::exception& e) {
3373       {
3374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3375       };
3376     } catch (...) {
3377       {
3378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3379       };
3380     }
3381   }
3382   jresult = result;
3383   return jresult;
3384 }
3385
3386
3387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3388   void * jresult ;
3389   Dali::Any *result = 0 ;
3390
3391   {
3392     try {
3393       result = (Dali::Any *)new Dali::Any();
3394     } catch (std::out_of_range& e) {
3395       {
3396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3397       };
3398     } catch (std::exception& e) {
3399       {
3400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3401       };
3402     } catch (...) {
3403       {
3404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3405       };
3406     }
3407   }
3408   jresult = (void *)result;
3409   return jresult;
3410 }
3411
3412
3413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3414   Dali::Any *arg1 = (Dali::Any *) 0 ;
3415
3416   arg1 = (Dali::Any *)jarg1;
3417   {
3418     try {
3419       delete arg1;
3420     } catch (std::out_of_range& e) {
3421       {
3422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (std::exception& e) {
3425       {
3426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434 }
3435
3436
3437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3438   char *arg1 = (char *) 0 ;
3439
3440   arg1 = (char *)jarg1;
3441   {
3442     try {
3443       Dali::Any::AssertAlways((char const *)arg1);
3444     } catch (std::out_of_range& e) {
3445       {
3446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3447       };
3448     } catch (std::exception& e) {
3449       {
3450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3451       };
3452     } catch (...) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3455       };
3456     }
3457   }
3458 }
3459
3460
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3462   void * jresult ;
3463   Dali::Any *arg1 = 0 ;
3464   Dali::Any *result = 0 ;
3465
3466   arg1 = (Dali::Any *)jarg1;
3467   if (!arg1) {
3468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3469     return 0;
3470   }
3471   {
3472     try {
3473       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3474     } catch (std::out_of_range& e) {
3475       {
3476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (std::exception& e) {
3479       {
3480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3481       };
3482     } catch (...) {
3483       {
3484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3485       };
3486     }
3487   }
3488   jresult = (void *)result;
3489   return jresult;
3490 }
3491
3492
3493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3494   void * jresult ;
3495   Dali::Any *arg1 = (Dali::Any *) 0 ;
3496   Dali::Any *arg2 = 0 ;
3497   Dali::Any *result = 0 ;
3498
3499   arg1 = (Dali::Any *)jarg1;
3500   arg2 = (Dali::Any *)jarg2;
3501   if (!arg2) {
3502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3503     return 0;
3504   }
3505   {
3506     try {
3507       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3508     } catch (std::out_of_range& e) {
3509       {
3510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3511       };
3512     } catch (std::exception& e) {
3513       {
3514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (...) {
3517       {
3518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3519       };
3520     }
3521   }
3522   jresult = (void *)result;
3523   return jresult;
3524 }
3525
3526
3527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3528   void * jresult ;
3529   Dali::Any *arg1 = (Dali::Any *) 0 ;
3530   std::type_info *result = 0 ;
3531
3532   arg1 = (Dali::Any *)jarg1;
3533   {
3534     try {
3535       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3536     } catch (std::out_of_range& e) {
3537       {
3538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3539       };
3540     } catch (std::exception& e) {
3541       {
3542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (...) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3547       };
3548     }
3549   }
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3556   unsigned int jresult ;
3557   Dali::Any *arg1 = (Dali::Any *) 0 ;
3558   bool result;
3559
3560   arg1 = (Dali::Any *)jarg1;
3561   {
3562     try {
3563       result = (bool)((Dali::Any const *)arg1)->Empty();
3564     } catch (std::out_of_range& e) {
3565       {
3566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3567       };
3568     } catch (std::exception& e) {
3569       {
3570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3575       };
3576     }
3577   }
3578   jresult = result;
3579   return jresult;
3580 }
3581
3582
3583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3584   void * jresult ;
3585   std::type_info *arg1 = 0 ;
3586   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3587   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3588   Dali::Any::AnyContainerBase *result = 0 ;
3589
3590   arg1 = (std::type_info *)jarg1;
3591   if (!arg1) {
3592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3593     return 0;
3594   }
3595   arg2 = (Dali::Any::CloneFunc)jarg2;
3596   arg3 = (Dali::Any::DeleteFunc)jarg3;
3597   {
3598     try {
3599       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3600     } catch (std::out_of_range& e) {
3601       {
3602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3603       };
3604     } catch (std::exception& e) {
3605       {
3606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3607       };
3608     } catch (...) {
3609       {
3610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3611       };
3612     }
3613   }
3614   jresult = (void *)result;
3615   return jresult;
3616 }
3617
3618
3619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3620   void * jresult ;
3621   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3622   std::type_info *result = 0 ;
3623
3624   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3625   {
3626     try {
3627       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3628     } catch (std::out_of_range& e) {
3629       {
3630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (std::exception& e) {
3633       {
3634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3648   void * jresult ;
3649   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3650   ::std::type_info *result = 0 ;
3651
3652   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3653   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3654   jresult = (void *)result;
3655   return jresult;
3656 }
3657
3658
3659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3660   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3661   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3662
3663   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3664   arg2 = (Dali::Any::CloneFunc)jarg2;
3665   if (arg1) (arg1)->mCloneFunc = arg2;
3666 }
3667
3668
3669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3670   void * jresult ;
3671   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3672   Dali::Any::CloneFunc result;
3673
3674   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3675   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3676   jresult = (void *)result;
3677   return jresult;
3678 }
3679
3680
3681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3682   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3683   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3684
3685   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3686   arg2 = (Dali::Any::DeleteFunc)jarg2;
3687   if (arg1) (arg1)->mDeleteFunc = arg2;
3688 }
3689
3690
3691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3692   void * jresult ;
3693   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3694   Dali::Any::DeleteFunc result;
3695
3696   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3697   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3698   jresult = (void *)result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3704   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3705
3706   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3707   {
3708     try {
3709       delete arg1;
3710     } catch (std::out_of_range& e) {
3711       {
3712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3713       };
3714     } catch (std::exception& e) {
3715       {
3716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3717       };
3718     } catch (...) {
3719       {
3720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3721       };
3722     }
3723   }
3724 }
3725
3726
3727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3728   Dali::Any *arg1 = (Dali::Any *) 0 ;
3729   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3730
3731   arg1 = (Dali::Any *)jarg1;
3732   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3733   if (arg1) (arg1)->mContainer = arg2;
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3738   void * jresult ;
3739   Dali::Any *arg1 = (Dali::Any *) 0 ;
3740   Dali::Any::AnyContainerBase *result = 0 ;
3741
3742   arg1 = (Dali::Any *)jarg1;
3743   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3744   jresult = (void *)result;
3745   return jresult;
3746 }
3747
3748
3749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3750   char *arg1 = (char *) 0 ;
3751   char *arg2 = (char *) 0 ;
3752
3753   arg1 = (char *)jarg1;
3754   arg2 = (char *)jarg2;
3755   {
3756     try {
3757       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3765       };
3766     } catch (...) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3769       };
3770     }
3771   }
3772 }
3773
3774
3775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3776   void * jresult ;
3777   char *arg1 = (char *) 0 ;
3778   char *arg2 = (char *) 0 ;
3779   Dali::DaliException *result = 0 ;
3780
3781   arg1 = (char *)jarg1;
3782   arg2 = (char *)jarg2;
3783   {
3784     try {
3785       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3786     } catch (std::out_of_range& e) {
3787       {
3788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3789       };
3790     } catch (std::exception& e) {
3791       {
3792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3793       };
3794     } catch (...) {
3795       {
3796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3797       };
3798     }
3799   }
3800   jresult = (void *)result;
3801   return jresult;
3802 }
3803
3804
3805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3806   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3807   char *arg2 = (char *) 0 ;
3808
3809   arg1 = (Dali::DaliException *)jarg1;
3810   arg2 = (char *)jarg2;
3811   {
3812     if (arg2) {
3813       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3814       strcpy((char *)arg1->location, (const char *)arg2);
3815     } else {
3816       arg1->location = 0;
3817     }
3818   }
3819 }
3820
3821
3822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3823   char * jresult ;
3824   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3825   char *result = 0 ;
3826
3827   arg1 = (Dali::DaliException *)jarg1;
3828   result = (char *) ((arg1)->location);
3829   jresult = SWIG_csharp_string_callback((const char *)result);
3830   return jresult;
3831 }
3832
3833
3834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3835   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3836   char *arg2 = (char *) 0 ;
3837
3838   arg1 = (Dali::DaliException *)jarg1;
3839   arg2 = (char *)jarg2;
3840   {
3841     if (arg2) {
3842       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3843       strcpy((char *)arg1->condition, (const char *)arg2);
3844     } else {
3845       arg1->condition = 0;
3846     }
3847   }
3848 }
3849
3850
3851 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3852   char * jresult ;
3853   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3854   char *result = 0 ;
3855
3856   arg1 = (Dali::DaliException *)jarg1;
3857   result = (char *) ((arg1)->condition);
3858   jresult = SWIG_csharp_string_callback((const char *)result);
3859   return jresult;
3860 }
3861
3862
3863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3864   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3865
3866   arg1 = (Dali::DaliException *)jarg1;
3867   {
3868     try {
3869       delete arg1;
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3881       };
3882     }
3883   }
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3888   void * jresult ;
3889   Dali::Vector2 *result = 0 ;
3890
3891   {
3892     try {
3893       result = (Dali::Vector2 *)new Dali::Vector2();
3894     } catch (std::out_of_range& e) {
3895       {
3896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3897       };
3898     } catch (std::exception& e) {
3899       {
3900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (...) {
3903       {
3904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3905       };
3906     }
3907   }
3908   jresult = (void *)result;
3909   return jresult;
3910 }
3911
3912
3913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3914   void * jresult ;
3915   float arg1 ;
3916   float arg2 ;
3917   Dali::Vector2 *result = 0 ;
3918
3919   arg1 = (float)jarg1;
3920   arg2 = (float)jarg2;
3921   {
3922     try {
3923       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3924     } catch (std::out_of_range& e) {
3925       {
3926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3927       };
3928     } catch (std::exception& e) {
3929       {
3930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3931       };
3932     } catch (...) {
3933       {
3934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3935       };
3936     }
3937   }
3938   jresult = (void *)result;
3939   return jresult;
3940 }
3941
3942
3943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3944   void * jresult ;
3945   float *arg1 = (float *) 0 ;
3946   Dali::Vector2 *result = 0 ;
3947
3948   arg1 = jarg1;
3949   {
3950     try {
3951       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3952     } catch (std::out_of_range& e) {
3953       {
3954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3955       };
3956     } catch (std::exception& e) {
3957       {
3958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3959       };
3960     } catch (...) {
3961       {
3962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3963       };
3964     }
3965   }
3966   jresult = (void *)result;
3967
3968
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3974   void * jresult ;
3975   Dali::Vector3 *arg1 = 0 ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   arg1 = (Dali::Vector3 *)jarg1;
3979   if (!arg1) {
3980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3981     return 0;
3982   }
3983   {
3984     try {
3985       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3986     } catch (std::out_of_range& e) {
3987       {
3988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3989       };
3990     } catch (std::exception& e) {
3991       {
3992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3993       };
3994     } catch (...) {
3995       {
3996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3997       };
3998     }
3999   }
4000   jresult = (void *)result;
4001   return jresult;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4006   void * jresult ;
4007   Dali::Vector4 *arg1 = 0 ;
4008   Dali::Vector2 *result = 0 ;
4009
4010   arg1 = (Dali::Vector4 *)jarg1;
4011   if (!arg1) {
4012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4013     return 0;
4014   }
4015   {
4016     try {
4017       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4018     } catch (std::out_of_range& e) {
4019       {
4020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4021       };
4022     } catch (std::exception& e) {
4023       {
4024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4025       };
4026     } catch (...) {
4027       {
4028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4029       };
4030     }
4031   }
4032   jresult = (void *)result;
4033   return jresult;
4034 }
4035
4036
4037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4038   void * jresult ;
4039   Dali::Vector2 *result = 0 ;
4040
4041   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4042   jresult = (void *)result;
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4048   void * jresult ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4052   jresult = (void *)result;
4053   return jresult;
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4058   void * jresult ;
4059   Dali::Vector2 *result = 0 ;
4060
4061   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4062   jresult = (void *)result;
4063   return jresult;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4068   void * jresult ;
4069   Dali::Vector2 *result = 0 ;
4070
4071   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4072   jresult = (void *)result;
4073   return jresult;
4074 }
4075
4076
4077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4078   void * jresult ;
4079   Dali::Vector2 *result = 0 ;
4080
4081   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4082   jresult = (void *)result;
4083   return jresult;
4084 }
4085
4086
4087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4088   void * jresult ;
4089   Dali::Vector2 *result = 0 ;
4090
4091   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4092   jresult = (void *)result;
4093   return jresult;
4094 }
4095
4096
4097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4098   void * jresult ;
4099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4100   float *arg2 = (float *) 0 ;
4101   Dali::Vector2 *result = 0 ;
4102
4103   arg1 = (Dali::Vector2 *)jarg1;
4104   arg2 = jarg2;
4105   {
4106     try {
4107       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4108     } catch (std::out_of_range& e) {
4109       {
4110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4111       };
4112     } catch (std::exception& e) {
4113       {
4114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (...) {
4117       {
4118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4119       };
4120     }
4121   }
4122   jresult = (void *)result;
4123
4124
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4130   void * jresult ;
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   Dali::Vector3 *arg2 = 0 ;
4133   Dali::Vector2 *result = 0 ;
4134
4135   arg1 = (Dali::Vector2 *)jarg1;
4136   arg2 = (Dali::Vector3 *)jarg2;
4137   if (!arg2) {
4138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4139     return 0;
4140   }
4141   {
4142     try {
4143       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4144     } catch (std::out_of_range& e) {
4145       {
4146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4147       };
4148     } catch (std::exception& e) {
4149       {
4150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4151       };
4152     } catch (...) {
4153       {
4154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4155       };
4156     }
4157   }
4158   jresult = (void *)result;
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4164   void * jresult ;
4165   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4166   Dali::Vector4 *arg2 = 0 ;
4167   Dali::Vector2 *result = 0 ;
4168
4169   arg1 = (Dali::Vector2 *)jarg1;
4170   arg2 = (Dali::Vector4 *)jarg2;
4171   if (!arg2) {
4172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4173     return 0;
4174   }
4175   {
4176     try {
4177       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4178     } catch (std::out_of_range& e) {
4179       {
4180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4181       };
4182     } catch (std::exception& e) {
4183       {
4184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (...) {
4187       {
4188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4189       };
4190     }
4191   }
4192   jresult = (void *)result;
4193   return jresult;
4194 }
4195
4196
4197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4198   void * jresult ;
4199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4200   Dali::Vector2 *arg2 = 0 ;
4201   Dali::Vector2 result;
4202
4203   arg1 = (Dali::Vector2 *)jarg1;
4204   arg2 = (Dali::Vector2 *)jarg2;
4205   if (!arg2) {
4206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4207     return 0;
4208   }
4209   {
4210     try {
4211       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4212     } catch (std::out_of_range& e) {
4213       {
4214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4215       };
4216     } catch (std::exception& e) {
4217       {
4218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4219       };
4220     } catch (...) {
4221       {
4222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4223       };
4224     }
4225   }
4226   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4232   void * jresult ;
4233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4234   Dali::Vector2 *arg2 = 0 ;
4235   Dali::Vector2 *result = 0 ;
4236
4237   arg1 = (Dali::Vector2 *)jarg1;
4238   arg2 = (Dali::Vector2 *)jarg2;
4239   if (!arg2) {
4240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4241     return 0;
4242   }
4243   {
4244     try {
4245       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4246     } catch (std::out_of_range& e) {
4247       {
4248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (std::exception& e) {
4251       {
4252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (...) {
4255       {
4256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4257       };
4258     }
4259   }
4260   jresult = (void *)result;
4261   return jresult;
4262 }
4263
4264
4265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4266   void * jresult ;
4267   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4268   Dali::Vector2 *arg2 = 0 ;
4269   Dali::Vector2 result;
4270
4271   arg1 = (Dali::Vector2 *)jarg1;
4272   arg2 = (Dali::Vector2 *)jarg2;
4273   if (!arg2) {
4274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4275     return 0;
4276   }
4277   {
4278     try {
4279       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4280     } catch (std::out_of_range& e) {
4281       {
4282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4283       };
4284     } catch (std::exception& e) {
4285       {
4286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4287       };
4288     } catch (...) {
4289       {
4290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4291       };
4292     }
4293   }
4294   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4295   return jresult;
4296 }
4297
4298
4299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4300   void * jresult ;
4301   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4302   Dali::Vector2 *arg2 = 0 ;
4303   Dali::Vector2 *result = 0 ;
4304
4305   arg1 = (Dali::Vector2 *)jarg1;
4306   arg2 = (Dali::Vector2 *)jarg2;
4307   if (!arg2) {
4308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4309     return 0;
4310   }
4311   {
4312     try {
4313       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4314     } catch (std::out_of_range& e) {
4315       {
4316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (std::exception& e) {
4319       {
4320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4321       };
4322     } catch (...) {
4323       {
4324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4325       };
4326     }
4327   }
4328   jresult = (void *)result;
4329   return jresult;
4330 }
4331
4332
4333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4334   void * jresult ;
4335   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4336   Dali::Vector2 *arg2 = 0 ;
4337   Dali::Vector2 result;
4338
4339   arg1 = (Dali::Vector2 *)jarg1;
4340   arg2 = (Dali::Vector2 *)jarg2;
4341   if (!arg2) {
4342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4343     return 0;
4344   }
4345   {
4346     try {
4347       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4348     } catch (std::out_of_range& e) {
4349       {
4350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4351       };
4352     } catch (std::exception& e) {
4353       {
4354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4355       };
4356     } catch (...) {
4357       {
4358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4359       };
4360     }
4361   }
4362   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4368   void * jresult ;
4369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4370   float arg2 ;
4371   Dali::Vector2 result;
4372
4373   arg1 = (Dali::Vector2 *)jarg1;
4374   arg2 = (float)jarg2;
4375   {
4376     try {
4377       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4378     } catch (std::out_of_range& e) {
4379       {
4380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (std::exception& e) {
4383       {
4384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4385       };
4386     } catch (...) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4389       };
4390     }
4391   }
4392   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4398   void * jresult ;
4399   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4400   Dali::Vector2 *arg2 = 0 ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   arg1 = (Dali::Vector2 *)jarg1;
4404   arg2 = (Dali::Vector2 *)jarg2;
4405   if (!arg2) {
4406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4407     return 0;
4408   }
4409   {
4410     try {
4411       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4412     } catch (std::out_of_range& e) {
4413       {
4414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4415       };
4416     } catch (std::exception& e) {
4417       {
4418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4419       };
4420     } catch (...) {
4421       {
4422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4423       };
4424     }
4425   }
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4432   void * jresult ;
4433   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4434   float arg2 ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   arg1 = (Dali::Vector2 *)jarg1;
4438   arg2 = (float)jarg2;
4439   {
4440     try {
4441       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4442     } catch (std::out_of_range& e) {
4443       {
4444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4445       };
4446     } catch (std::exception& e) {
4447       {
4448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (...) {
4451       {
4452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4453       };
4454     }
4455   }
4456   jresult = (void *)result;
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4462   void * jresult ;
4463   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4464   Dali::Vector2 *arg2 = 0 ;
4465   Dali::Vector2 result;
4466
4467   arg1 = (Dali::Vector2 *)jarg1;
4468   arg2 = (Dali::Vector2 *)jarg2;
4469   if (!arg2) {
4470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4471     return 0;
4472   }
4473   {
4474     try {
4475       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4476     } catch (std::out_of_range& e) {
4477       {
4478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4479       };
4480     } catch (std::exception& e) {
4481       {
4482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4483       };
4484     } catch (...) {
4485       {
4486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4487       };
4488     }
4489   }
4490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4491   return jresult;
4492 }
4493
4494
4495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4496   void * jresult ;
4497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4498   float arg2 ;
4499   Dali::Vector2 result;
4500
4501   arg1 = (Dali::Vector2 *)jarg1;
4502   arg2 = (float)jarg2;
4503   {
4504     try {
4505       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4506     } catch (std::out_of_range& e) {
4507       {
4508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (std::exception& e) {
4511       {
4512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (...) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4517       };
4518     }
4519   }
4520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4526   void * jresult ;
4527   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4528   Dali::Vector2 *arg2 = 0 ;
4529   Dali::Vector2 *result = 0 ;
4530
4531   arg1 = (Dali::Vector2 *)jarg1;
4532   arg2 = (Dali::Vector2 *)jarg2;
4533   if (!arg2) {
4534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4535     return 0;
4536   }
4537   {
4538     try {
4539       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4540     } catch (std::out_of_range& e) {
4541       {
4542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4543       };
4544     } catch (std::exception& e) {
4545       {
4546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (...) {
4549       {
4550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4551       };
4552     }
4553   }
4554   jresult = (void *)result;
4555   return jresult;
4556 }
4557
4558
4559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4560   void * jresult ;
4561   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4562   float arg2 ;
4563   Dali::Vector2 *result = 0 ;
4564
4565   arg1 = (Dali::Vector2 *)jarg1;
4566   arg2 = (float)jarg2;
4567   {
4568     try {
4569       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4570     } catch (std::out_of_range& e) {
4571       {
4572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (std::exception& e) {
4575       {
4576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4577       };
4578     } catch (...) {
4579       {
4580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4581       };
4582     }
4583   }
4584   jresult = (void *)result;
4585   return jresult;
4586 }
4587
4588
4589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4590   void * jresult ;
4591   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4592   Dali::Vector2 result;
4593
4594   arg1 = (Dali::Vector2 *)jarg1;
4595   {
4596     try {
4597       result = ((Dali::Vector2 const *)arg1)->operator -();
4598     } catch (std::out_of_range& e) {
4599       {
4600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (std::exception& e) {
4603       {
4604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4605       };
4606     } catch (...) {
4607       {
4608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4609       };
4610     }
4611   }
4612   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4613   return jresult;
4614 }
4615
4616
4617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4618   unsigned int jresult ;
4619   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4620   Dali::Vector2 *arg2 = 0 ;
4621   bool result;
4622
4623   arg1 = (Dali::Vector2 *)jarg1;
4624   arg2 = (Dali::Vector2 *)jarg2;
4625   if (!arg2) {
4626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4627     return 0;
4628   }
4629   {
4630     try {
4631       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4632     } catch (std::out_of_range& e) {
4633       {
4634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (std::exception& e) {
4637       {
4638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646   jresult = result;
4647   return jresult;
4648 }
4649
4650
4651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4652   unsigned int jresult ;
4653   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4654   Dali::Vector2 *arg2 = 0 ;
4655   bool result;
4656
4657   arg1 = (Dali::Vector2 *)jarg1;
4658   arg2 = (Dali::Vector2 *)jarg2;
4659   if (!arg2) {
4660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4661     return 0;
4662   }
4663   {
4664     try {
4665       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4666     } catch (std::out_of_range& e) {
4667       {
4668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (std::exception& e) {
4671       {
4672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (...) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4677       };
4678     }
4679   }
4680   jresult = result;
4681   return jresult;
4682 }
4683
4684
4685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4686   float jresult ;
4687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4688   unsigned int arg2 ;
4689   float *result = 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   arg2 = (unsigned int)jarg2;
4693   {
4694     try {
4695       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (...) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4707       };
4708     }
4709   }
4710   jresult = *result;
4711   return jresult;
4712 }
4713
4714
4715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4716   float jresult ;
4717   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4718   float result;
4719
4720   arg1 = (Dali::Vector2 *)jarg1;
4721   {
4722     try {
4723       result = (float)((Dali::Vector2 const *)arg1)->Length();
4724     } catch (std::out_of_range& e) {
4725       {
4726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4727       };
4728     } catch (std::exception& e) {
4729       {
4730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4731       };
4732     } catch (...) {
4733       {
4734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4735       };
4736     }
4737   }
4738   jresult = result;
4739   return jresult;
4740 }
4741
4742
4743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4744   float jresult ;
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float result;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   {
4750     try {
4751       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4752     } catch (std::out_of_range& e) {
4753       {
4754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4755       };
4756     } catch (std::exception& e) {
4757       {
4758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4759       };
4760     } catch (...) {
4761       {
4762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4763       };
4764     }
4765   }
4766   jresult = result;
4767   return jresult;
4768 }
4769
4770
4771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4772   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   {
4776     try {
4777       (arg1)->Normalize();
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4785       };
4786     } catch (...) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4789       };
4790     }
4791   }
4792 }
4793
4794
4795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4797   Dali::Vector2 *arg2 = 0 ;
4798   Dali::Vector2 *arg3 = 0 ;
4799
4800   arg1 = (Dali::Vector2 *)jarg1;
4801   arg2 = (Dali::Vector2 *)jarg2;
4802   if (!arg2) {
4803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4804     return ;
4805   }
4806   arg3 = (Dali::Vector2 *)jarg3;
4807   if (!arg3) {
4808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4809     return ;
4810   }
4811   {
4812     try {
4813       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4814     } catch (std::out_of_range& e) {
4815       {
4816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4817       };
4818     } catch (std::exception& e) {
4819       {
4820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4821       };
4822     } catch (...) {
4823       {
4824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4825       };
4826     }
4827   }
4828 }
4829
4830
4831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4832   void * jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   float *result = 0 ;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   {
4838     try {
4839       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4840     } catch (std::out_of_range& e) {
4841       {
4842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4843       };
4844     } catch (std::exception& e) {
4845       {
4846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4847       };
4848     } catch (...) {
4849       {
4850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4851       };
4852     }
4853   }
4854   jresult = (void *)result;
4855   return jresult;
4856 }
4857
4858
4859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4860   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4861   float arg2 ;
4862
4863   arg1 = (Dali::Vector2 *)jarg1;
4864   arg2 = (float)jarg2;
4865   if (arg1) (arg1)->x = arg2;
4866 }
4867
4868
4869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4870   float jresult ;
4871   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4872   float result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   result = (float) ((arg1)->x);
4876   jresult = result;
4877   return jresult;
4878 }
4879
4880
4881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4882   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4883   float arg2 ;
4884
4885   arg1 = (Dali::Vector2 *)jarg1;
4886   arg2 = (float)jarg2;
4887   if (arg1) (arg1)->width = arg2;
4888 }
4889
4890
4891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4892   float jresult ;
4893   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4894   float result;
4895
4896   arg1 = (Dali::Vector2 *)jarg1;
4897   result = (float) ((arg1)->width);
4898   jresult = result;
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4904   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4905   float arg2 ;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (float)jarg2;
4909   if (arg1) (arg1)->y = arg2;
4910 }
4911
4912
4913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4914   float jresult ;
4915   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4916   float result;
4917
4918   arg1 = (Dali::Vector2 *)jarg1;
4919   result = (float) ((arg1)->y);
4920   jresult = result;
4921   return jresult;
4922 }
4923
4924
4925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4926   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4927   float arg2 ;
4928
4929   arg1 = (Dali::Vector2 *)jarg1;
4930   arg2 = (float)jarg2;
4931   if (arg1) (arg1)->height = arg2;
4932 }
4933
4934
4935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4936   float jresult ;
4937   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4938   float result;
4939
4940   arg1 = (Dali::Vector2 *)jarg1;
4941   result = (float) ((arg1)->height);
4942   jresult = result;
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4948   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   {
4952     try {
4953       delete arg1;
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4961       };
4962     } catch (...) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4965       };
4966     }
4967   }
4968 }
4969
4970
4971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4972   void * jresult ;
4973   Dali::Vector2 *arg1 = 0 ;
4974   Dali::Vector2 *arg2 = 0 ;
4975   Dali::Vector2 result;
4976
4977   arg1 = (Dali::Vector2 *)jarg1;
4978   if (!arg1) {
4979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4980     return 0;
4981   }
4982   arg2 = (Dali::Vector2 *)jarg2;
4983   if (!arg2) {
4984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4985     return 0;
4986   }
4987   {
4988     try {
4989       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4990     } catch (std::out_of_range& e) {
4991       {
4992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (std::exception& e) {
4995       {
4996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5010   void * jresult ;
5011   Dali::Vector2 *arg1 = 0 ;
5012   Dali::Vector2 *arg2 = 0 ;
5013   Dali::Vector2 result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   if (!arg1) {
5017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5018     return 0;
5019   }
5020   arg2 = (Dali::Vector2 *)jarg2;
5021   if (!arg2) {
5022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5023     return 0;
5024   }
5025   {
5026     try {
5027       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5028     } catch (std::out_of_range& e) {
5029       {
5030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5031       };
5032     } catch (std::exception& e) {
5033       {
5034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (...) {
5037       {
5038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5039       };
5040     }
5041   }
5042   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5043   return jresult;
5044 }
5045
5046
5047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5048   void * jresult ;
5049   Dali::Vector2 *arg1 = 0 ;
5050   float *arg2 = 0 ;
5051   float *arg3 = 0 ;
5052   float temp2 ;
5053   float temp3 ;
5054   Dali::Vector2 result;
5055
5056   arg1 = (Dali::Vector2 *)jarg1;
5057   if (!arg1) {
5058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5059     return 0;
5060   }
5061   temp2 = (float)jarg2;
5062   arg2 = &temp2;
5063   temp3 = (float)jarg3;
5064   arg3 = &temp3;
5065   {
5066     try {
5067       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5068     } catch (std::out_of_range& e) {
5069       {
5070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (std::exception& e) {
5073       {
5074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (...) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5079       };
5080     }
5081   }
5082   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5083   return jresult;
5084 }
5085
5086
5087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5088   void * jresult ;
5089   Dali::Vector3 *result = 0 ;
5090
5091   {
5092     try {
5093       result = (Dali::Vector3 *)new Dali::Vector3();
5094     } catch (std::out_of_range& e) {
5095       {
5096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5097       };
5098     } catch (std::exception& e) {
5099       {
5100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5101       };
5102     } catch (...) {
5103       {
5104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5105       };
5106     }
5107   }
5108   jresult = (void *)result;
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5114   void * jresult ;
5115   float arg1 ;
5116   float arg2 ;
5117   float arg3 ;
5118   Dali::Vector3 *result = 0 ;
5119
5120   arg1 = (float)jarg1;
5121   arg2 = (float)jarg2;
5122   arg3 = (float)jarg3;
5123   {
5124     try {
5125       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5126     } catch (std::out_of_range& e) {
5127       {
5128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5129       };
5130     } catch (std::exception& e) {
5131       {
5132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5133       };
5134     } catch (...) {
5135       {
5136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5137       };
5138     }
5139   }
5140   jresult = (void *)result;
5141   return jresult;
5142 }
5143
5144
5145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5146   void * jresult ;
5147   float *arg1 = (float *) 0 ;
5148   Dali::Vector3 *result = 0 ;
5149
5150   arg1 = jarg1;
5151   {
5152     try {
5153       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5154     } catch (std::out_of_range& e) {
5155       {
5156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5157       };
5158     } catch (std::exception& e) {
5159       {
5160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5161       };
5162     } catch (...) {
5163       {
5164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5165       };
5166     }
5167   }
5168   jresult = (void *)result;
5169
5170
5171   return jresult;
5172 }
5173
5174
5175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5176   void * jresult ;
5177   Dali::Vector2 *arg1 = 0 ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   arg1 = (Dali::Vector2 *)jarg1;
5181   if (!arg1) {
5182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5183     return 0;
5184   }
5185   {
5186     try {
5187       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5188     } catch (std::out_of_range& e) {
5189       {
5190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5191       };
5192     } catch (std::exception& e) {
5193       {
5194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5195       };
5196     } catch (...) {
5197       {
5198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5199       };
5200     }
5201   }
5202   jresult = (void *)result;
5203   return jresult;
5204 }
5205
5206
5207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5208   void * jresult ;
5209   Dali::Vector4 *arg1 = 0 ;
5210   Dali::Vector3 *result = 0 ;
5211
5212   arg1 = (Dali::Vector4 *)jarg1;
5213   if (!arg1) {
5214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5215     return 0;
5216   }
5217   {
5218     try {
5219       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5220     } catch (std::out_of_range& e) {
5221       {
5222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5223       };
5224     } catch (std::exception& e) {
5225       {
5226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5227       };
5228     } catch (...) {
5229       {
5230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5231       };
5232     }
5233   }
5234   jresult = (void *)result;
5235   return jresult;
5236 }
5237
5238
5239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5240   void * jresult ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5244   jresult = (void *)result;
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5250   void * jresult ;
5251   Dali::Vector3 *result = 0 ;
5252
5253   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5254   jresult = (void *)result;
5255   return jresult;
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5260   void * jresult ;
5261   Dali::Vector3 *result = 0 ;
5262
5263   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5264   jresult = (void *)result;
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5270   void * jresult ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5274   jresult = (void *)result;
5275   return jresult;
5276 }
5277
5278
5279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5280   void * jresult ;
5281   Dali::Vector3 *result = 0 ;
5282
5283   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5284   jresult = (void *)result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5290   void * jresult ;
5291   Dali::Vector3 *result = 0 ;
5292
5293   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5294   jresult = (void *)result;
5295   return jresult;
5296 }
5297
5298
5299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5300   void * jresult ;
5301   Dali::Vector3 *result = 0 ;
5302
5303   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5304   jresult = (void *)result;
5305   return jresult;
5306 }
5307
5308
5309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5310   void * jresult ;
5311   Dali::Vector3 *result = 0 ;
5312
5313   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5314   jresult = (void *)result;
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5320   void * jresult ;
5321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5322   float *arg2 = (float *) 0 ;
5323   Dali::Vector3 *result = 0 ;
5324
5325   arg1 = (Dali::Vector3 *)jarg1;
5326   arg2 = jarg2;
5327   {
5328     try {
5329       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5330     } catch (std::out_of_range& e) {
5331       {
5332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5333       };
5334     } catch (std::exception& e) {
5335       {
5336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (...) {
5339       {
5340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5341       };
5342     }
5343   }
5344   jresult = (void *)result;
5345
5346
5347   return jresult;
5348 }
5349
5350
5351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5352   void * jresult ;
5353   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5354   Dali::Vector2 *arg2 = 0 ;
5355   Dali::Vector3 *result = 0 ;
5356
5357   arg1 = (Dali::Vector3 *)jarg1;
5358   arg2 = (Dali::Vector2 *)jarg2;
5359   if (!arg2) {
5360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5361     return 0;
5362   }
5363   {
5364     try {
5365       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5366     } catch (std::out_of_range& e) {
5367       {
5368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5369       };
5370     } catch (std::exception& e) {
5371       {
5372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5373       };
5374     } catch (...) {
5375       {
5376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5377       };
5378     }
5379   }
5380   jresult = (void *)result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5386   void * jresult ;
5387   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5388   Dali::Vector4 *arg2 = 0 ;
5389   Dali::Vector3 *result = 0 ;
5390
5391   arg1 = (Dali::Vector3 *)jarg1;
5392   arg2 = (Dali::Vector4 *)jarg2;
5393   if (!arg2) {
5394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5395     return 0;
5396   }
5397   {
5398     try {
5399       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5400     } catch (std::out_of_range& e) {
5401       {
5402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5403       };
5404     } catch (std::exception& e) {
5405       {
5406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5407       };
5408     } catch (...) {
5409       {
5410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5411       };
5412     }
5413   }
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5420   void * jresult ;
5421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5422   Dali::Vector3 *arg2 = 0 ;
5423   Dali::Vector3 result;
5424
5425   arg1 = (Dali::Vector3 *)jarg1;
5426   arg2 = (Dali::Vector3 *)jarg2;
5427   if (!arg2) {
5428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5429     return 0;
5430   }
5431   {
5432     try {
5433       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5456   Dali::Vector3 *arg2 = 0 ;
5457   Dali::Vector3 *result = 0 ;
5458
5459   arg1 = (Dali::Vector3 *)jarg1;
5460   arg2 = (Dali::Vector3 *)jarg2;
5461   if (!arg2) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5463     return 0;
5464   }
5465   {
5466     try {
5467       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5468     } catch (std::out_of_range& e) {
5469       {
5470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (std::exception& e) {
5473       {
5474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482   jresult = (void *)result;
5483   return jresult;
5484 }
5485
5486
5487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5488   void * jresult ;
5489   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5490   Dali::Vector3 *arg2 = 0 ;
5491   Dali::Vector3 result;
5492
5493   arg1 = (Dali::Vector3 *)jarg1;
5494   arg2 = (Dali::Vector3 *)jarg2;
5495   if (!arg2) {
5496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5497     return 0;
5498   }
5499   {
5500     try {
5501       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5502     } catch (std::out_of_range& e) {
5503       {
5504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5505       };
5506     } catch (std::exception& e) {
5507       {
5508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5509       };
5510     } catch (...) {
5511       {
5512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5513       };
5514     }
5515   }
5516   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5517   return jresult;
5518 }
5519
5520
5521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5522   void * jresult ;
5523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5524   Dali::Vector3 *arg2 = 0 ;
5525   Dali::Vector3 *result = 0 ;
5526
5527   arg1 = (Dali::Vector3 *)jarg1;
5528   arg2 = (Dali::Vector3 *)jarg2;
5529   if (!arg2) {
5530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5531     return 0;
5532   }
5533   {
5534     try {
5535       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5536     } catch (std::out_of_range& e) {
5537       {
5538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (std::exception& e) {
5541       {
5542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5543       };
5544     } catch (...) {
5545       {
5546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5547       };
5548     }
5549   }
5550   jresult = (void *)result;
5551   return jresult;
5552 }
5553
5554
5555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5556   void * jresult ;
5557   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5558   Dali::Vector3 *arg2 = 0 ;
5559   Dali::Vector3 result;
5560
5561   arg1 = (Dali::Vector3 *)jarg1;
5562   arg2 = (Dali::Vector3 *)jarg2;
5563   if (!arg2) {
5564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5565     return 0;
5566   }
5567   {
5568     try {
5569       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (...) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5581       };
5582     }
5583   }
5584   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5590   void * jresult ;
5591   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5592   float arg2 ;
5593   Dali::Vector3 result;
5594
5595   arg1 = (Dali::Vector3 *)jarg1;
5596   arg2 = (float)jarg2;
5597   {
5598     try {
5599       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5615   return jresult;
5616 }
5617
5618
5619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5620   void * jresult ;
5621   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5622   Dali::Vector3 *arg2 = 0 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (Dali::Vector3 *)jarg1;
5626   arg2 = (Dali::Vector3 *)jarg2;
5627   if (!arg2) {
5628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5629     return 0;
5630   }
5631   {
5632     try {
5633       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5634     } catch (std::out_of_range& e) {
5635       {
5636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (std::exception& e) {
5639       {
5640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5654   void * jresult ;
5655   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5656   float arg2 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = (Dali::Vector3 *)jarg1;
5660   arg2 = (float)jarg2;
5661   {
5662     try {
5663       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (...) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5675       };
5676     }
5677   }
5678   jresult = (void *)result;
5679   return jresult;
5680 }
5681
5682
5683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5684   void * jresult ;
5685   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5686   Dali::Quaternion *arg2 = 0 ;
5687   Dali::Vector3 *result = 0 ;
5688
5689   arg1 = (Dali::Vector3 *)jarg1;
5690   arg2 = (Dali::Quaternion *)jarg2;
5691   if (!arg2) {
5692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5693     return 0;
5694   }
5695   {
5696     try {
5697       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5698     } catch (std::out_of_range& e) {
5699       {
5700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (std::exception& e) {
5703       {
5704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (...) {
5707       {
5708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5709       };
5710     }
5711   }
5712   jresult = (void *)result;
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5718   void * jresult ;
5719   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5720   Dali::Vector3 *arg2 = 0 ;
5721   Dali::Vector3 result;
5722
5723   arg1 = (Dali::Vector3 *)jarg1;
5724   arg2 = (Dali::Vector3 *)jarg2;
5725   if (!arg2) {
5726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5727     return 0;
5728   }
5729   {
5730     try {
5731       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5732     } catch (std::out_of_range& e) {
5733       {
5734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5735       };
5736     } catch (std::exception& e) {
5737       {
5738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5739       };
5740     } catch (...) {
5741       {
5742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5743       };
5744     }
5745   }
5746   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5747   return jresult;
5748 }
5749
5750
5751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5752   void * jresult ;
5753   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5754   float arg2 ;
5755   Dali::Vector3 result;
5756
5757   arg1 = (Dali::Vector3 *)jarg1;
5758   arg2 = (float)jarg2;
5759   {
5760     try {
5761       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5762     } catch (std::out_of_range& e) {
5763       {
5764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5765       };
5766     } catch (std::exception& e) {
5767       {
5768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5769       };
5770     } catch (...) {
5771       {
5772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5773       };
5774     }
5775   }
5776   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5782   void * jresult ;
5783   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5784   Dali::Vector3 *arg2 = 0 ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   arg1 = (Dali::Vector3 *)jarg1;
5788   arg2 = (Dali::Vector3 *)jarg2;
5789   if (!arg2) {
5790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5791     return 0;
5792   }
5793   {
5794     try {
5795       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5796     } catch (std::out_of_range& e) {
5797       {
5798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5799       };
5800     } catch (std::exception& e) {
5801       {
5802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5803       };
5804     } catch (...) {
5805       {
5806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5807       };
5808     }
5809   }
5810   jresult = (void *)result;
5811   return jresult;
5812 }
5813
5814
5815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5816   void * jresult ;
5817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5818   float arg2 ;
5819   Dali::Vector3 *result = 0 ;
5820
5821   arg1 = (Dali::Vector3 *)jarg1;
5822   arg2 = (float)jarg2;
5823   {
5824     try {
5825       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5826     } catch (std::out_of_range& e) {
5827       {
5828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5829       };
5830     } catch (std::exception& e) {
5831       {
5832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5833       };
5834     } catch (...) {
5835       {
5836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5837       };
5838     }
5839   }
5840   jresult = (void *)result;
5841   return jresult;
5842 }
5843
5844
5845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5846   void * jresult ;
5847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5848   Dali::Vector3 result;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   {
5852     try {
5853       result = ((Dali::Vector3 const *)arg1)->operator -();
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (...) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5865       };
5866     }
5867   }
5868   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5869   return jresult;
5870 }
5871
5872
5873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5874   unsigned int jresult ;
5875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5876   Dali::Vector3 *arg2 = 0 ;
5877   bool result;
5878
5879   arg1 = (Dali::Vector3 *)jarg1;
5880   arg2 = (Dali::Vector3 *)jarg2;
5881   if (!arg2) {
5882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5883     return 0;
5884   }
5885   {
5886     try {
5887       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5888     } catch (std::out_of_range& e) {
5889       {
5890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (std::exception& e) {
5893       {
5894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (...) {
5897       {
5898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5899       };
5900     }
5901   }
5902   jresult = result;
5903   return jresult;
5904 }
5905
5906
5907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5908   unsigned int jresult ;
5909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5910   Dali::Vector3 *arg2 = 0 ;
5911   bool result;
5912
5913   arg1 = (Dali::Vector3 *)jarg1;
5914   arg2 = (Dali::Vector3 *)jarg2;
5915   if (!arg2) {
5916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5917     return 0;
5918   }
5919   {
5920     try {
5921       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5922     } catch (std::out_of_range& e) {
5923       {
5924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5925       };
5926     } catch (std::exception& e) {
5927       {
5928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5929       };
5930     } catch (...) {
5931       {
5932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5933       };
5934     }
5935   }
5936   jresult = result;
5937   return jresult;
5938 }
5939
5940
5941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5942   float jresult ;
5943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5944   unsigned int arg2 ;
5945   float *result = 0 ;
5946
5947   arg1 = (Dali::Vector3 *)jarg1;
5948   arg2 = (unsigned int)jarg2;
5949   {
5950     try {
5951       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5952     } catch (std::out_of_range& e) {
5953       {
5954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (std::exception& e) {
5957       {
5958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5959       };
5960     } catch (...) {
5961       {
5962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5963       };
5964     }
5965   }
5966   jresult = *result;
5967   return jresult;
5968 }
5969
5970
5971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5972   float jresult ;
5973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5974   Dali::Vector3 *arg2 = 0 ;
5975   float result;
5976
5977   arg1 = (Dali::Vector3 *)jarg1;
5978   arg2 = (Dali::Vector3 *)jarg2;
5979   if (!arg2) {
5980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5981     return 0;
5982   }
5983   {
5984     try {
5985       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5986     } catch (std::out_of_range& e) {
5987       {
5988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (std::exception& e) {
5991       {
5992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5993       };
5994     } catch (...) {
5995       {
5996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5997       };
5998     }
5999   }
6000   jresult = result;
6001   return jresult;
6002 }
6003
6004
6005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6006   void * jresult ;
6007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6008   Dali::Vector3 *arg2 = 0 ;
6009   Dali::Vector3 result;
6010
6011   arg1 = (Dali::Vector3 *)jarg1;
6012   arg2 = (Dali::Vector3 *)jarg2;
6013   if (!arg2) {
6014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6015     return 0;
6016   }
6017   {
6018     try {
6019       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (...) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6031       };
6032     }
6033   }
6034   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6040   float jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   float result;
6043
6044   arg1 = (Dali::Vector3 *)jarg1;
6045   {
6046     try {
6047       result = (float)((Dali::Vector3 const *)arg1)->Length();
6048     } catch (std::out_of_range& e) {
6049       {
6050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (std::exception& e) {
6053       {
6054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (...) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6059       };
6060     }
6061   }
6062   jresult = result;
6063   return jresult;
6064 }
6065
6066
6067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6068   float jresult ;
6069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6070   float result;
6071
6072   arg1 = (Dali::Vector3 *)jarg1;
6073   {
6074     try {
6075       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6076     } catch (std::out_of_range& e) {
6077       {
6078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6079       };
6080     } catch (std::exception& e) {
6081       {
6082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (...) {
6085       {
6086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6087       };
6088     }
6089   }
6090   jresult = result;
6091   return jresult;
6092 }
6093
6094
6095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6097
6098   arg1 = (Dali::Vector3 *)jarg1;
6099   {
6100     try {
6101       (arg1)->Normalize();
6102     } catch (std::out_of_range& e) {
6103       {
6104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6105       };
6106     } catch (std::exception& e) {
6107       {
6108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6113       };
6114     }
6115   }
6116 }
6117
6118
6119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6120   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6121   Dali::Vector3 *arg2 = 0 ;
6122   Dali::Vector3 *arg3 = 0 ;
6123
6124   arg1 = (Dali::Vector3 *)jarg1;
6125   arg2 = (Dali::Vector3 *)jarg2;
6126   if (!arg2) {
6127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6128     return ;
6129   }
6130   arg3 = (Dali::Vector3 *)jarg3;
6131   if (!arg3) {
6132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6133     return ;
6134   }
6135   {
6136     try {
6137       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6149       };
6150     }
6151   }
6152 }
6153
6154
6155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6156   void * jresult ;
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float *result = 0 ;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   {
6162     try {
6163       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (...) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6175       };
6176     }
6177   }
6178   jresult = (void *)result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   Dali::Vector2 *result = 0 ;
6187
6188   arg1 = (Dali::Vector3 *)jarg1;
6189   {
6190     try {
6191       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6192     } catch (std::out_of_range& e) {
6193       {
6194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6195       };
6196     } catch (std::exception& e) {
6197       {
6198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (...) {
6201       {
6202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6203       };
6204     }
6205   }
6206   jresult = (void *)result;
6207   return jresult;
6208 }
6209
6210
6211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6212   void * jresult ;
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   Dali::Vector2 *result = 0 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   {
6218     try {
6219       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6220     } catch (std::out_of_range& e) {
6221       {
6222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6223       };
6224     } catch (std::exception& e) {
6225       {
6226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6227       };
6228     } catch (...) {
6229       {
6230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6231       };
6232     }
6233   }
6234   jresult = (void *)result;
6235   return jresult;
6236 }
6237
6238
6239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6240   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6241   float arg2 ;
6242
6243   arg1 = (Dali::Vector3 *)jarg1;
6244   arg2 = (float)jarg2;
6245   if (arg1) (arg1)->x = arg2;
6246 }
6247
6248
6249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6250   float jresult ;
6251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6252   float result;
6253
6254   arg1 = (Dali::Vector3 *)jarg1;
6255   result = (float) ((arg1)->x);
6256   jresult = result;
6257   return jresult;
6258 }
6259
6260
6261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6262   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6263   float arg2 ;
6264
6265   arg1 = (Dali::Vector3 *)jarg1;
6266   arg2 = (float)jarg2;
6267   if (arg1) (arg1)->width = arg2;
6268 }
6269
6270
6271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6272   float jresult ;
6273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6274   float result;
6275
6276   arg1 = (Dali::Vector3 *)jarg1;
6277   result = (float) ((arg1)->width);
6278   jresult = result;
6279   return jresult;
6280 }
6281
6282
6283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6284   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6285   float arg2 ;
6286
6287   arg1 = (Dali::Vector3 *)jarg1;
6288   arg2 = (float)jarg2;
6289   if (arg1) (arg1)->r = arg2;
6290 }
6291
6292
6293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6294   float jresult ;
6295   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6296   float result;
6297
6298   arg1 = (Dali::Vector3 *)jarg1;
6299   result = (float) ((arg1)->r);
6300   jresult = result;
6301   return jresult;
6302 }
6303
6304
6305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   float arg2 ;
6308
6309   arg1 = (Dali::Vector3 *)jarg1;
6310   arg2 = (float)jarg2;
6311   if (arg1) (arg1)->y = arg2;
6312 }
6313
6314
6315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6316   float jresult ;
6317   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6318   float result;
6319
6320   arg1 = (Dali::Vector3 *)jarg1;
6321   result = (float) ((arg1)->y);
6322   jresult = result;
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6328   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6329   float arg2 ;
6330
6331   arg1 = (Dali::Vector3 *)jarg1;
6332   arg2 = (float)jarg2;
6333   if (arg1) (arg1)->height = arg2;
6334 }
6335
6336
6337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6338   float jresult ;
6339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6340   float result;
6341
6342   arg1 = (Dali::Vector3 *)jarg1;
6343   result = (float) ((arg1)->height);
6344   jresult = result;
6345   return jresult;
6346 }
6347
6348
6349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6351   float arg2 ;
6352
6353   arg1 = (Dali::Vector3 *)jarg1;
6354   arg2 = (float)jarg2;
6355   if (arg1) (arg1)->g = arg2;
6356 }
6357
6358
6359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6360   float jresult ;
6361   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6362   float result;
6363
6364   arg1 = (Dali::Vector3 *)jarg1;
6365   result = (float) ((arg1)->g);
6366   jresult = result;
6367   return jresult;
6368 }
6369
6370
6371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   float arg2 ;
6374
6375   arg1 = (Dali::Vector3 *)jarg1;
6376   arg2 = (float)jarg2;
6377   if (arg1) (arg1)->z = arg2;
6378 }
6379
6380
6381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6382   float jresult ;
6383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6384   float result;
6385
6386   arg1 = (Dali::Vector3 *)jarg1;
6387   result = (float) ((arg1)->z);
6388   jresult = result;
6389   return jresult;
6390 }
6391
6392
6393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6394   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6395   float arg2 ;
6396
6397   arg1 = (Dali::Vector3 *)jarg1;
6398   arg2 = (float)jarg2;
6399   if (arg1) (arg1)->depth = arg2;
6400 }
6401
6402
6403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6404   float jresult ;
6405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6406   float result;
6407
6408   arg1 = (Dali::Vector3 *)jarg1;
6409   result = (float) ((arg1)->depth);
6410   jresult = result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418
6419   arg1 = (Dali::Vector3 *)jarg1;
6420   arg2 = (float)jarg2;
6421   if (arg1) (arg1)->b = arg2;
6422 }
6423
6424
6425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6426   float jresult ;
6427   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6428   float result;
6429
6430   arg1 = (Dali::Vector3 *)jarg1;
6431   result = (float) ((arg1)->b);
6432   jresult = result;
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439
6440   arg1 = (Dali::Vector3 *)jarg1;
6441   {
6442     try {
6443       delete arg1;
6444     } catch (std::out_of_range& e) {
6445       {
6446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6447       };
6448     } catch (std::exception& e) {
6449       {
6450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6451       };
6452     } catch (...) {
6453       {
6454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6455       };
6456     }
6457   }
6458 }
6459
6460
6461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6462   void * jresult ;
6463   Dali::Vector3 *arg1 = 0 ;
6464   Dali::Vector3 *arg2 = 0 ;
6465   Dali::Vector3 result;
6466
6467   arg1 = (Dali::Vector3 *)jarg1;
6468   if (!arg1) {
6469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6470     return 0;
6471   }
6472   arg2 = (Dali::Vector3 *)jarg2;
6473   if (!arg2) {
6474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6475     return 0;
6476   }
6477   {
6478     try {
6479       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6480     } catch (std::out_of_range& e) {
6481       {
6482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (std::exception& e) {
6485       {
6486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (...) {
6489       {
6490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6491       };
6492     }
6493   }
6494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6495   return jresult;
6496 }
6497
6498
6499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6500   void * jresult ;
6501   Dali::Vector3 *arg1 = 0 ;
6502   Dali::Vector3 *arg2 = 0 ;
6503   Dali::Vector3 result;
6504
6505   arg1 = (Dali::Vector3 *)jarg1;
6506   if (!arg1) {
6507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6508     return 0;
6509   }
6510   arg2 = (Dali::Vector3 *)jarg2;
6511   if (!arg2) {
6512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6513     return 0;
6514   }
6515   {
6516     try {
6517       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6518     } catch (std::out_of_range& e) {
6519       {
6520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6521       };
6522     } catch (std::exception& e) {
6523       {
6524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6525       };
6526     } catch (...) {
6527       {
6528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6529       };
6530     }
6531   }
6532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6538   void * jresult ;
6539   Dali::Vector3 *arg1 = 0 ;
6540   float *arg2 = 0 ;
6541   float *arg3 = 0 ;
6542   float temp2 ;
6543   float temp3 ;
6544   Dali::Vector3 result;
6545
6546   arg1 = (Dali::Vector3 *)jarg1;
6547   if (!arg1) {
6548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6549     return 0;
6550   }
6551   temp2 = (float)jarg2;
6552   arg2 = &temp2;
6553   temp3 = (float)jarg3;
6554   arg3 = &temp3;
6555   {
6556     try {
6557       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6558     } catch (std::out_of_range& e) {
6559       {
6560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6561       };
6562     } catch (std::exception& e) {
6563       {
6564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (...) {
6567       {
6568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6569       };
6570     }
6571   }
6572   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6573   return jresult;
6574 }
6575
6576
6577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6578   void * jresult ;
6579   Dali::Vector4 *result = 0 ;
6580
6581   {
6582     try {
6583       result = (Dali::Vector4 *)new Dali::Vector4();
6584     } catch (std::out_of_range& e) {
6585       {
6586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (std::exception& e) {
6589       {
6590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598   jresult = (void *)result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6604   void * jresult ;
6605   float arg1 ;
6606   float arg2 ;
6607   float arg3 ;
6608   float arg4 ;
6609   Dali::Vector4 *result = 0 ;
6610
6611   arg1 = (float)jarg1;
6612   arg2 = (float)jarg2;
6613   arg3 = (float)jarg3;
6614   arg4 = (float)jarg4;
6615   {
6616     try {
6617       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6618     } catch (std::out_of_range& e) {
6619       {
6620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6621       };
6622     } catch (std::exception& e) {
6623       {
6624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (...) {
6627       {
6628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6629       };
6630     }
6631   }
6632   jresult = (void *)result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6638   void * jresult ;
6639   float *arg1 = (float *) 0 ;
6640   Dali::Vector4 *result = 0 ;
6641
6642   arg1 = jarg1;
6643   {
6644     try {
6645       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (...) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6657       };
6658     }
6659   }
6660   jresult = (void *)result;
6661
6662
6663   return jresult;
6664 }
6665
6666
6667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6668   void * jresult ;
6669   Dali::Vector2 *arg1 = 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector2 *)jarg1;
6673   if (!arg1) {
6674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6675     return 0;
6676   }
6677   {
6678     try {
6679       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (...) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6691       };
6692     }
6693   }
6694   jresult = (void *)result;
6695   return jresult;
6696 }
6697
6698
6699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6700   void * jresult ;
6701   Dali::Vector3 *arg1 = 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector3 *)jarg1;
6705   if (!arg1) {
6706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6707     return 0;
6708   }
6709   {
6710     try {
6711       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (...) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6723       };
6724     }
6725   }
6726   jresult = (void *)result;
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6732   void * jresult ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6742   void * jresult ;
6743   Dali::Vector4 *result = 0 ;
6744
6745   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6752   void * jresult ;
6753   Dali::Vector4 *result = 0 ;
6754
6755   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6762   void * jresult ;
6763   Dali::Vector4 *result = 0 ;
6764
6765   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6766   jresult = (void *)result;
6767   return jresult;
6768 }
6769
6770
6771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6772   void * jresult ;
6773   Dali::Vector4 *result = 0 ;
6774
6775   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6776   jresult = (void *)result;
6777   return jresult;
6778 }
6779
6780
6781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6782   void * jresult ;
6783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6784   float *arg2 = (float *) 0 ;
6785   Dali::Vector4 *result = 0 ;
6786
6787   arg1 = (Dali::Vector4 *)jarg1;
6788   arg2 = jarg2;
6789   {
6790     try {
6791       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6792     } catch (std::out_of_range& e) {
6793       {
6794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6795       };
6796     } catch (std::exception& e) {
6797       {
6798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6803       };
6804     }
6805   }
6806   jresult = (void *)result;
6807
6808
6809   return jresult;
6810 }
6811
6812
6813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6814   void * jresult ;
6815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6816   Dali::Vector2 *arg2 = 0 ;
6817   Dali::Vector4 *result = 0 ;
6818
6819   arg1 = (Dali::Vector4 *)jarg1;
6820   arg2 = (Dali::Vector2 *)jarg2;
6821   if (!arg2) {
6822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6823     return 0;
6824   }
6825   {
6826     try {
6827       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6828     } catch (std::out_of_range& e) {
6829       {
6830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (std::exception& e) {
6833       {
6834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6835       };
6836     } catch (...) {
6837       {
6838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6839       };
6840     }
6841   }
6842   jresult = (void *)result;
6843   return jresult;
6844 }
6845
6846
6847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6848   void * jresult ;
6849   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6850   Dali::Vector3 *arg2 = 0 ;
6851   Dali::Vector4 *result = 0 ;
6852
6853   arg1 = (Dali::Vector4 *)jarg1;
6854   arg2 = (Dali::Vector3 *)jarg2;
6855   if (!arg2) {
6856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6857     return 0;
6858   }
6859   {
6860     try {
6861       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6862     } catch (std::out_of_range& e) {
6863       {
6864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6865       };
6866     } catch (std::exception& e) {
6867       {
6868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6869       };
6870     } catch (...) {
6871       {
6872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6873       };
6874     }
6875   }
6876   jresult = (void *)result;
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6882   void * jresult ;
6883   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6884   Dali::Vector4 *arg2 = 0 ;
6885   Dali::Vector4 result;
6886
6887   arg1 = (Dali::Vector4 *)jarg1;
6888   arg2 = (Dali::Vector4 *)jarg2;
6889   if (!arg2) {
6890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6891     return 0;
6892   }
6893   {
6894     try {
6895       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6896     } catch (std::out_of_range& e) {
6897       {
6898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (std::exception& e) {
6901       {
6902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6911   return jresult;
6912 }
6913
6914
6915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6916   void * jresult ;
6917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6918   Dali::Vector4 *arg2 = 0 ;
6919   Dali::Vector4 *result = 0 ;
6920
6921   arg1 = (Dali::Vector4 *)jarg1;
6922   arg2 = (Dali::Vector4 *)jarg2;
6923   if (!arg2) {
6924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6925     return 0;
6926   }
6927   {
6928     try {
6929       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6930     } catch (std::out_of_range& e) {
6931       {
6932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6933       };
6934     } catch (std::exception& e) {
6935       {
6936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6937       };
6938     } catch (...) {
6939       {
6940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6941       };
6942     }
6943   }
6944   jresult = (void *)result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6950   void * jresult ;
6951   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6952   Dali::Vector4 *arg2 = 0 ;
6953   Dali::Vector4 result;
6954
6955   arg1 = (Dali::Vector4 *)jarg1;
6956   arg2 = (Dali::Vector4 *)jarg2;
6957   if (!arg2) {
6958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6959     return 0;
6960   }
6961   {
6962     try {
6963       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6964     } catch (std::out_of_range& e) {
6965       {
6966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6967       };
6968     } catch (std::exception& e) {
6969       {
6970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6971       };
6972     } catch (...) {
6973       {
6974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6975       };
6976     }
6977   }
6978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6979   return jresult;
6980 }
6981
6982
6983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6984   void * jresult ;
6985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6986   Dali::Vector4 *arg2 = 0 ;
6987   Dali::Vector4 *result = 0 ;
6988
6989   arg1 = (Dali::Vector4 *)jarg1;
6990   arg2 = (Dali::Vector4 *)jarg2;
6991   if (!arg2) {
6992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6993     return 0;
6994   }
6995   {
6996     try {
6997       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6998     } catch (std::out_of_range& e) {
6999       {
7000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (std::exception& e) {
7003       {
7004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7005       };
7006     } catch (...) {
7007       {
7008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7009       };
7010     }
7011   }
7012   jresult = (void *)result;
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7018   void * jresult ;
7019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7020   Dali::Vector4 *arg2 = 0 ;
7021   Dali::Vector4 result;
7022
7023   arg1 = (Dali::Vector4 *)jarg1;
7024   arg2 = (Dali::Vector4 *)jarg2;
7025   if (!arg2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7027     return 0;
7028   }
7029   {
7030     try {
7031       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7032     } catch (std::out_of_range& e) {
7033       {
7034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7035       };
7036     } catch (std::exception& e) {
7037       {
7038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7039       };
7040     } catch (...) {
7041       {
7042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7043       };
7044     }
7045   }
7046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7047   return jresult;
7048 }
7049
7050
7051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7052   void * jresult ;
7053   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7054   float arg2 ;
7055   Dali::Vector4 result;
7056
7057   arg1 = (Dali::Vector4 *)jarg1;
7058   arg2 = (float)jarg2;
7059   {
7060     try {
7061       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7062     } catch (std::out_of_range& e) {
7063       {
7064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (std::exception& e) {
7067       {
7068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7069       };
7070     } catch (...) {
7071       {
7072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7073       };
7074     }
7075   }
7076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7082   void * jresult ;
7083   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7084   Dali::Vector4 *arg2 = 0 ;
7085   Dali::Vector4 *result = 0 ;
7086
7087   arg1 = (Dali::Vector4 *)jarg1;
7088   arg2 = (Dali::Vector4 *)jarg2;
7089   if (!arg2) {
7090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7091     return 0;
7092   }
7093   {
7094     try {
7095       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7096     } catch (std::out_of_range& e) {
7097       {
7098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7099       };
7100     } catch (std::exception& e) {
7101       {
7102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7103       };
7104     } catch (...) {
7105       {
7106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7107       };
7108     }
7109   }
7110   jresult = (void *)result;
7111   return jresult;
7112 }
7113
7114
7115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7116   void * jresult ;
7117   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7118   float arg2 ;
7119   Dali::Vector4 *result = 0 ;
7120
7121   arg1 = (Dali::Vector4 *)jarg1;
7122   arg2 = (float)jarg2;
7123   {
7124     try {
7125       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7126     } catch (std::out_of_range& e) {
7127       {
7128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7129       };
7130     } catch (std::exception& e) {
7131       {
7132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7133       };
7134     } catch (...) {
7135       {
7136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7137       };
7138     }
7139   }
7140   jresult = (void *)result;
7141   return jresult;
7142 }
7143
7144
7145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7146   void * jresult ;
7147   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7148   Dali::Vector4 *arg2 = 0 ;
7149   Dali::Vector4 result;
7150
7151   arg1 = (Dali::Vector4 *)jarg1;
7152   arg2 = (Dali::Vector4 *)jarg2;
7153   if (!arg2) {
7154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7155     return 0;
7156   }
7157   {
7158     try {
7159       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7160     } catch (std::out_of_range& e) {
7161       {
7162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7163       };
7164     } catch (std::exception& e) {
7165       {
7166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7167       };
7168     } catch (...) {
7169       {
7170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7171       };
7172     }
7173   }
7174   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7180   void * jresult ;
7181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7182   float arg2 ;
7183   Dali::Vector4 result;
7184
7185   arg1 = (Dali::Vector4 *)jarg1;
7186   arg2 = (float)jarg2;
7187   {
7188     try {
7189       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7190     } catch (std::out_of_range& e) {
7191       {
7192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7193       };
7194     } catch (std::exception& e) {
7195       {
7196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (...) {
7199       {
7200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7201       };
7202     }
7203   }
7204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7205   return jresult;
7206 }
7207
7208
7209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7210   void * jresult ;
7211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7212   Dali::Vector4 *arg2 = 0 ;
7213   Dali::Vector4 *result = 0 ;
7214
7215   arg1 = (Dali::Vector4 *)jarg1;
7216   arg2 = (Dali::Vector4 *)jarg2;
7217   if (!arg2) {
7218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7219     return 0;
7220   }
7221   {
7222     try {
7223       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7224     } catch (std::out_of_range& e) {
7225       {
7226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7227       };
7228     } catch (std::exception& e) {
7229       {
7230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7231       };
7232     } catch (...) {
7233       {
7234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7235       };
7236     }
7237   }
7238   jresult = (void *)result;
7239   return jresult;
7240 }
7241
7242
7243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7244   void * jresult ;
7245   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7246   float arg2 ;
7247   Dali::Vector4 *result = 0 ;
7248
7249   arg1 = (Dali::Vector4 *)jarg1;
7250   arg2 = (float)jarg2;
7251   {
7252     try {
7253       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7254     } catch (std::out_of_range& e) {
7255       {
7256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (std::exception& e) {
7259       {
7260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7261       };
7262     } catch (...) {
7263       {
7264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7265       };
7266     }
7267   }
7268   jresult = (void *)result;
7269   return jresult;
7270 }
7271
7272
7273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7274   void * jresult ;
7275   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7276   Dali::Vector4 result;
7277
7278   arg1 = (Dali::Vector4 *)jarg1;
7279   {
7280     try {
7281       result = ((Dali::Vector4 const *)arg1)->operator -();
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (...) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7293       };
7294     }
7295   }
7296   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7297   return jresult;
7298 }
7299
7300
7301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7302   unsigned int jresult ;
7303   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7304   Dali::Vector4 *arg2 = 0 ;
7305   bool result;
7306
7307   arg1 = (Dali::Vector4 *)jarg1;
7308   arg2 = (Dali::Vector4 *)jarg2;
7309   if (!arg2) {
7310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7311     return 0;
7312   }
7313   {
7314     try {
7315       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7316     } catch (std::out_of_range& e) {
7317       {
7318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (std::exception& e) {
7321       {
7322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330   jresult = result;
7331   return jresult;
7332 }
7333
7334
7335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7336   unsigned int jresult ;
7337   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7338   Dali::Vector4 *arg2 = 0 ;
7339   bool result;
7340
7341   arg1 = (Dali::Vector4 *)jarg1;
7342   arg2 = (Dali::Vector4 *)jarg2;
7343   if (!arg2) {
7344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7345     return 0;
7346   }
7347   {
7348     try {
7349       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7350     } catch (std::out_of_range& e) {
7351       {
7352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (std::exception& e) {
7355       {
7356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364   jresult = result;
7365   return jresult;
7366 }
7367
7368
7369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7370   float jresult ;
7371   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7372   unsigned int arg2 ;
7373   float *result = 0 ;
7374
7375   arg1 = (Dali::Vector4 *)jarg1;
7376   arg2 = (unsigned int)jarg2;
7377   {
7378     try {
7379       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7380     } catch (std::out_of_range& e) {
7381       {
7382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (std::exception& e) {
7385       {
7386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394   jresult = *result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7400   float jresult ;
7401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7402   Dali::Vector3 *arg2 = 0 ;
7403   float result;
7404
7405   arg1 = (Dali::Vector4 *)jarg1;
7406   arg2 = (Dali::Vector3 *)jarg2;
7407   if (!arg2) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7414     } catch (std::out_of_range& e) {
7415       {
7416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (std::exception& e) {
7419       {
7420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428   jresult = result;
7429   return jresult;
7430 }
7431
7432
7433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7434   float jresult ;
7435   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7436   Dali::Vector4 *arg2 = 0 ;
7437   float result;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   arg2 = (Dali::Vector4 *)jarg2;
7441   if (!arg2) {
7442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7443     return 0;
7444   }
7445   {
7446     try {
7447       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7448     } catch (std::out_of_range& e) {
7449       {
7450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (std::exception& e) {
7453       {
7454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7455       };
7456     } catch (...) {
7457       {
7458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7459       };
7460     }
7461   }
7462   jresult = result;
7463   return jresult;
7464 }
7465
7466
7467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7468   float jresult ;
7469   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7470   Dali::Vector4 *arg2 = 0 ;
7471   float result;
7472
7473   arg1 = (Dali::Vector4 *)jarg1;
7474   arg2 = (Dali::Vector4 *)jarg2;
7475   if (!arg2) {
7476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7477     return 0;
7478   }
7479   {
7480     try {
7481       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7482     } catch (std::out_of_range& e) {
7483       {
7484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (std::exception& e) {
7487       {
7488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7489       };
7490     } catch (...) {
7491       {
7492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7493       };
7494     }
7495   }
7496   jresult = result;
7497   return jresult;
7498 }
7499
7500
7501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7502   void * jresult ;
7503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7504   Dali::Vector4 *arg2 = 0 ;
7505   Dali::Vector4 result;
7506
7507   arg1 = (Dali::Vector4 *)jarg1;
7508   arg2 = (Dali::Vector4 *)jarg2;
7509   if (!arg2) {
7510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7511     return 0;
7512   }
7513   {
7514     try {
7515       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7516     } catch (std::out_of_range& e) {
7517       {
7518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7519       };
7520     } catch (std::exception& e) {
7521       {
7522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7527       };
7528     }
7529   }
7530   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7536   float jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   float result;
7539
7540   arg1 = (Dali::Vector4 *)jarg1;
7541   {
7542     try {
7543       result = (float)((Dali::Vector4 const *)arg1)->Length();
7544     } catch (std::out_of_range& e) {
7545       {
7546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (std::exception& e) {
7549       {
7550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (...) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7555       };
7556     }
7557   }
7558   jresult = result;
7559   return jresult;
7560 }
7561
7562
7563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7564   float jresult ;
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float result;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   {
7570     try {
7571       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7572     } catch (std::out_of_range& e) {
7573       {
7574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7575       };
7576     } catch (std::exception& e) {
7577       {
7578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (...) {
7581       {
7582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7583       };
7584     }
7585   }
7586   jresult = result;
7587   return jresult;
7588 }
7589
7590
7591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   {
7596     try {
7597       (arg1)->Normalize();
7598     } catch (std::out_of_range& e) {
7599       {
7600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7601       };
7602     } catch (std::exception& e) {
7603       {
7604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7605       };
7606     } catch (...) {
7607       {
7608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7609       };
7610     }
7611   }
7612 }
7613
7614
7615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7616   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7617   Dali::Vector4 *arg2 = 0 ;
7618   Dali::Vector4 *arg3 = 0 ;
7619
7620   arg1 = (Dali::Vector4 *)jarg1;
7621   arg2 = (Dali::Vector4 *)jarg2;
7622   if (!arg2) {
7623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7624     return ;
7625   }
7626   arg3 = (Dali::Vector4 *)jarg3;
7627   if (!arg3) {
7628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7629     return ;
7630   }
7631   {
7632     try {
7633       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7634     } catch (std::out_of_range& e) {
7635       {
7636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7637       };
7638     } catch (std::exception& e) {
7639       {
7640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7641       };
7642     } catch (...) {
7643       {
7644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7645       };
7646     }
7647   }
7648 }
7649
7650
7651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7652   void * jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   {
7658     try {
7659       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7660     } catch (std::out_of_range& e) {
7661       {
7662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7663       };
7664     } catch (std::exception& e) {
7665       {
7666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (...) {
7669       {
7670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7671       };
7672     }
7673   }
7674   jresult = (void *)result;
7675   return jresult;
7676 }
7677
7678
7679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7681   float arg2 ;
7682
7683   arg1 = (Dali::Vector4 *)jarg1;
7684   arg2 = (float)jarg2;
7685   if (arg1) (arg1)->x = arg2;
7686 }
7687
7688
7689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7690   float jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   float result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   result = (float) ((arg1)->x);
7696   jresult = result;
7697   return jresult;
7698 }
7699
7700
7701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7703   float arg2 ;
7704
7705   arg1 = (Dali::Vector4 *)jarg1;
7706   arg2 = (float)jarg2;
7707   if (arg1) (arg1)->r = arg2;
7708 }
7709
7710
7711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7712   float jresult ;
7713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7714   float result;
7715
7716   arg1 = (Dali::Vector4 *)jarg1;
7717   result = (float) ((arg1)->r);
7718   jresult = result;
7719   return jresult;
7720 }
7721
7722
7723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   float arg2 ;
7726
7727   arg1 = (Dali::Vector4 *)jarg1;
7728   arg2 = (float)jarg2;
7729   if (arg1) (arg1)->s = arg2;
7730 }
7731
7732
7733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7734   float jresult ;
7735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7736   float result;
7737
7738   arg1 = (Dali::Vector4 *)jarg1;
7739   result = (float) ((arg1)->s);
7740   jresult = result;
7741   return jresult;
7742 }
7743
7744
7745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7747   float arg2 ;
7748
7749   arg1 = (Dali::Vector4 *)jarg1;
7750   arg2 = (float)jarg2;
7751   if (arg1) (arg1)->y = arg2;
7752 }
7753
7754
7755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7756   float jresult ;
7757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7758   float result;
7759
7760   arg1 = (Dali::Vector4 *)jarg1;
7761   result = (float) ((arg1)->y);
7762   jresult = result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   float arg2 ;
7770
7771   arg1 = (Dali::Vector4 *)jarg1;
7772   arg2 = (float)jarg2;
7773   if (arg1) (arg1)->g = arg2;
7774 }
7775
7776
7777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7778   float jresult ;
7779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7780   float result;
7781
7782   arg1 = (Dali::Vector4 *)jarg1;
7783   result = (float) ((arg1)->g);
7784   jresult = result;
7785   return jresult;
7786 }
7787
7788
7789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7791   float arg2 ;
7792
7793   arg1 = (Dali::Vector4 *)jarg1;
7794   arg2 = (float)jarg2;
7795   if (arg1) (arg1)->t = arg2;
7796 }
7797
7798
7799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7800   float jresult ;
7801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7802   float result;
7803
7804   arg1 = (Dali::Vector4 *)jarg1;
7805   result = (float) ((arg1)->t);
7806   jresult = result;
7807   return jresult;
7808 }
7809
7810
7811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7813   float arg2 ;
7814
7815   arg1 = (Dali::Vector4 *)jarg1;
7816   arg2 = (float)jarg2;
7817   if (arg1) (arg1)->z = arg2;
7818 }
7819
7820
7821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7822   float jresult ;
7823   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7824   float result;
7825
7826   arg1 = (Dali::Vector4 *)jarg1;
7827   result = (float) ((arg1)->z);
7828   jresult = result;
7829   return jresult;
7830 }
7831
7832
7833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7835   float arg2 ;
7836
7837   arg1 = (Dali::Vector4 *)jarg1;
7838   arg2 = (float)jarg2;
7839   if (arg1) (arg1)->b = arg2;
7840 }
7841
7842
7843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7844   float jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   float result;
7847
7848   arg1 = (Dali::Vector4 *)jarg1;
7849   result = (float) ((arg1)->b);
7850   jresult = result;
7851   return jresult;
7852 }
7853
7854
7855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7856   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7857   float arg2 ;
7858
7859   arg1 = (Dali::Vector4 *)jarg1;
7860   arg2 = (float)jarg2;
7861   if (arg1) (arg1)->p = arg2;
7862 }
7863
7864
7865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7866   float jresult ;
7867   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7868   float result;
7869
7870   arg1 = (Dali::Vector4 *)jarg1;
7871   result = (float) ((arg1)->p);
7872   jresult = result;
7873   return jresult;
7874 }
7875
7876
7877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7879   float arg2 ;
7880
7881   arg1 = (Dali::Vector4 *)jarg1;
7882   arg2 = (float)jarg2;
7883   if (arg1) (arg1)->w = arg2;
7884 }
7885
7886
7887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7888   float jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float result;
7891
7892   arg1 = (Dali::Vector4 *)jarg1;
7893   result = (float) ((arg1)->w);
7894   jresult = result;
7895   return jresult;
7896 }
7897
7898
7899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7900   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7901   float arg2 ;
7902
7903   arg1 = (Dali::Vector4 *)jarg1;
7904   arg2 = (float)jarg2;
7905   if (arg1) (arg1)->a = arg2;
7906 }
7907
7908
7909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7910   float jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   float result;
7913
7914   arg1 = (Dali::Vector4 *)jarg1;
7915   result = (float) ((arg1)->a);
7916   jresult = result;
7917   return jresult;
7918 }
7919
7920
7921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7922   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7923   float arg2 ;
7924
7925   arg1 = (Dali::Vector4 *)jarg1;
7926   arg2 = (float)jarg2;
7927   if (arg1) (arg1)->q = arg2;
7928 }
7929
7930
7931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7932   float jresult ;
7933   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7934   float result;
7935
7936   arg1 = (Dali::Vector4 *)jarg1;
7937   result = (float) ((arg1)->q);
7938   jresult = result;
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   {
7948     try {
7949       delete arg1;
7950     } catch (std::out_of_range& e) {
7951       {
7952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7953       };
7954     } catch (std::exception& e) {
7955       {
7956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7957       };
7958     } catch (...) {
7959       {
7960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7961       };
7962     }
7963   }
7964 }
7965
7966
7967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7968   void * jresult ;
7969   Dali::Vector4 *arg1 = 0 ;
7970   Dali::Vector4 *arg2 = 0 ;
7971   Dali::Vector4 result;
7972
7973   arg1 = (Dali::Vector4 *)jarg1;
7974   if (!arg1) {
7975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7976     return 0;
7977   }
7978   arg2 = (Dali::Vector4 *)jarg2;
7979   if (!arg2) {
7980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7981     return 0;
7982   }
7983   {
7984     try {
7985       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7986     } catch (std::out_of_range& e) {
7987       {
7988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (std::exception& e) {
7991       {
7992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (...) {
7995       {
7996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7997       };
7998     }
7999   }
8000   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8001   return jresult;
8002 }
8003
8004
8005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8006   void * jresult ;
8007   Dali::Vector4 *arg1 = 0 ;
8008   Dali::Vector4 *arg2 = 0 ;
8009   Dali::Vector4 result;
8010
8011   arg1 = (Dali::Vector4 *)jarg1;
8012   if (!arg1) {
8013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8014     return 0;
8015   }
8016   arg2 = (Dali::Vector4 *)jarg2;
8017   if (!arg2) {
8018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8019     return 0;
8020   }
8021   {
8022     try {
8023       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8024     } catch (std::out_of_range& e) {
8025       {
8026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (std::exception& e) {
8029       {
8030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (...) {
8033       {
8034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8035       };
8036     }
8037   }
8038   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8039   return jresult;
8040 }
8041
8042
8043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8044   void * jresult ;
8045   Dali::Vector4 *arg1 = 0 ;
8046   float *arg2 = 0 ;
8047   float *arg3 = 0 ;
8048   float temp2 ;
8049   float temp3 ;
8050   Dali::Vector4 result;
8051
8052   arg1 = (Dali::Vector4 *)jarg1;
8053   if (!arg1) {
8054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8055     return 0;
8056   }
8057   temp2 = (float)jarg2;
8058   arg2 = &temp2;
8059   temp3 = (float)jarg3;
8060   arg3 = &temp3;
8061   {
8062     try {
8063       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8064     } catch (std::out_of_range& e) {
8065       {
8066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (std::exception& e) {
8069       {
8070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (...) {
8073       {
8074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8075       };
8076     }
8077   }
8078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8079   return jresult;
8080 }
8081
8082
8083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8084   void * jresult ;
8085   Dali::Uint16Pair *result = 0 ;
8086
8087   {
8088     try {
8089       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8090     } catch (std::out_of_range& e) {
8091       {
8092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8093       };
8094     } catch (std::exception& e) {
8095       {
8096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8097       };
8098     } catch (...) {
8099       {
8100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8101       };
8102     }
8103   }
8104   jresult = (void *)result;
8105   return jresult;
8106 }
8107
8108
8109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8110   void * jresult ;
8111   uint32_t arg1 ;
8112   uint32_t arg2 ;
8113   Dali::Uint16Pair *result = 0 ;
8114
8115   arg1 = (uint32_t)jarg1;
8116   arg2 = (uint32_t)jarg2;
8117   {
8118     try {
8119       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8120     } catch (std::out_of_range& e) {
8121       {
8122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8123       };
8124     } catch (std::exception& e) {
8125       {
8126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8127       };
8128     } catch (...) {
8129       {
8130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8131       };
8132     }
8133   }
8134   jresult = (void *)result;
8135   return jresult;
8136 }
8137
8138
8139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8140   void * jresult ;
8141   Dali::Uint16Pair *arg1 = 0 ;
8142   Dali::Uint16Pair *result = 0 ;
8143
8144   arg1 = (Dali::Uint16Pair *)jarg1;
8145   if (!arg1) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (...) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8163       };
8164     }
8165   }
8166   jresult = (void *)result;
8167   return jresult;
8168 }
8169
8170
8171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8172   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8173   uint16_t arg2 ;
8174
8175   arg1 = (Dali::Uint16Pair *)jarg1;
8176   arg2 = (uint16_t)jarg2;
8177   {
8178     try {
8179       (arg1)->SetWidth(arg2);
8180     } catch (std::out_of_range& e) {
8181       {
8182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8183       };
8184     } catch (std::exception& e) {
8185       {
8186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8187       };
8188     } catch (...) {
8189       {
8190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8191       };
8192     }
8193   }
8194 }
8195
8196
8197 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8198   unsigned short jresult ;
8199   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8200   uint16_t result;
8201
8202   arg1 = (Dali::Uint16Pair *)jarg1;
8203   {
8204     try {
8205       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8206     } catch (std::out_of_range& e) {
8207       {
8208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8209       };
8210     } catch (std::exception& e) {
8211       {
8212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8213       };
8214     } catch (...) {
8215       {
8216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8217       };
8218     }
8219   }
8220   jresult = result;
8221   return jresult;
8222 }
8223
8224
8225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8226   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8227   uint16_t arg2 ;
8228
8229   arg1 = (Dali::Uint16Pair *)jarg1;
8230   arg2 = (uint16_t)jarg2;
8231   {
8232     try {
8233       (arg1)->SetHeight(arg2);
8234     } catch (std::out_of_range& e) {
8235       {
8236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8237       };
8238     } catch (std::exception& e) {
8239       {
8240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8241       };
8242     } catch (...) {
8243       {
8244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8245       };
8246     }
8247   }
8248 }
8249
8250
8251 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8252   unsigned short jresult ;
8253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8254   uint16_t result;
8255
8256   arg1 = (Dali::Uint16Pair *)jarg1;
8257   {
8258     try {
8259       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (...) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8271       };
8272     }
8273   }
8274   jresult = result;
8275   return jresult;
8276 }
8277
8278
8279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8281   uint16_t arg2 ;
8282
8283   arg1 = (Dali::Uint16Pair *)jarg1;
8284   arg2 = (uint16_t)jarg2;
8285   {
8286     try {
8287       (arg1)->SetX(arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8295       };
8296     } catch (...) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8299       };
8300     }
8301   }
8302 }
8303
8304
8305 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8306   unsigned short jresult ;
8307   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8308   uint16_t result;
8309
8310   arg1 = (Dali::Uint16Pair *)jarg1;
8311   {
8312     try {
8313       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8314     } catch (std::out_of_range& e) {
8315       {
8316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8317       };
8318     } catch (std::exception& e) {
8319       {
8320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8321       };
8322     } catch (...) {
8323       {
8324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8325       };
8326     }
8327   }
8328   jresult = result;
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8335   uint16_t arg2 ;
8336
8337   arg1 = (Dali::Uint16Pair *)jarg1;
8338   arg2 = (uint16_t)jarg2;
8339   {
8340     try {
8341       (arg1)->SetY(arg2);
8342     } catch (std::out_of_range& e) {
8343       {
8344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8345       };
8346     } catch (std::exception& e) {
8347       {
8348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8353       };
8354     }
8355   }
8356 }
8357
8358
8359 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8360   unsigned short jresult ;
8361   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8362   uint16_t result;
8363
8364   arg1 = (Dali::Uint16Pair *)jarg1;
8365   {
8366     try {
8367       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (...) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8379       };
8380     }
8381   }
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8388   void * jresult ;
8389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8390   Dali::Uint16Pair *arg2 = 0 ;
8391   Dali::Uint16Pair *result = 0 ;
8392
8393   arg1 = (Dali::Uint16Pair *)jarg1;
8394   arg2 = (Dali::Uint16Pair *)jarg2;
8395   if (!arg2) {
8396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8397     return 0;
8398   }
8399   {
8400     try {
8401       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8402     } catch (std::out_of_range& e) {
8403       {
8404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8405       };
8406     } catch (std::exception& e) {
8407       {
8408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (...) {
8411       {
8412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8413       };
8414     }
8415   }
8416   jresult = (void *)result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8422   unsigned int jresult ;
8423   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8424   Dali::Uint16Pair *arg2 = 0 ;
8425   bool result;
8426
8427   arg1 = (Dali::Uint16Pair *)jarg1;
8428   arg2 = (Dali::Uint16Pair *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8436     } catch (std::out_of_range& e) {
8437       {
8438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8439       };
8440     } catch (std::exception& e) {
8441       {
8442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8447       };
8448     }
8449   }
8450   jresult = result;
8451   return jresult;
8452 }
8453
8454
8455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8456   unsigned int jresult ;
8457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8458   Dali::Uint16Pair *arg2 = 0 ;
8459   bool result;
8460
8461   arg1 = (Dali::Uint16Pair *)jarg1;
8462   arg2 = (Dali::Uint16Pair *)jarg2;
8463   if (!arg2) {
8464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8465     return 0;
8466   }
8467   {
8468     try {
8469       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8470     } catch (std::out_of_range& e) {
8471       {
8472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8473       };
8474     } catch (std::exception& e) {
8475       {
8476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8477       };
8478     } catch (...) {
8479       {
8480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8481       };
8482     }
8483   }
8484   jresult = result;
8485   return jresult;
8486 }
8487
8488
8489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8490   unsigned int jresult ;
8491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8492   Dali::Uint16Pair *arg2 = 0 ;
8493   bool result;
8494
8495   arg1 = (Dali::Uint16Pair *)jarg1;
8496   arg2 = (Dali::Uint16Pair *)jarg2;
8497   if (!arg2) {
8498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8499     return 0;
8500   }
8501   {
8502     try {
8503       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (...) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8515       };
8516     }
8517   }
8518   jresult = result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8524   unsigned int jresult ;
8525   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8526   Dali::Uint16Pair *arg2 = 0 ;
8527   bool result;
8528
8529   arg1 = (Dali::Uint16Pair *)jarg1;
8530   arg2 = (Dali::Uint16Pair *)jarg2;
8531   if (!arg2) {
8532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8533     return 0;
8534   }
8535   {
8536     try {
8537       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8538     } catch (std::out_of_range& e) {
8539       {
8540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8541       };
8542     } catch (std::exception& e) {
8543       {
8544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8545       };
8546     } catch (...) {
8547       {
8548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8549       };
8550     }
8551   }
8552   jresult = result;
8553   return jresult;
8554 }
8555
8556
8557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8558   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8559
8560   arg1 = (Dali::Uint16Pair *)jarg1;
8561   {
8562     try {
8563       delete arg1;
8564     } catch (std::out_of_range& e) {
8565       {
8566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8567       };
8568     } catch (std::exception& e) {
8569       {
8570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8571       };
8572     } catch (...) {
8573       {
8574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8575       };
8576     }
8577   }
8578 }
8579
8580
8581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8582   void * jresult ;
8583   Dali::Degree *result = 0 ;
8584
8585   {
8586     try {
8587       result = (Dali::Degree *)new Dali::Degree();
8588     } catch (std::out_of_range& e) {
8589       {
8590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8591       };
8592     } catch (std::exception& e) {
8593       {
8594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8595       };
8596     } catch (...) {
8597       {
8598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8599       };
8600     }
8601   }
8602   jresult = (void *)result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8608   void * jresult ;
8609   float arg1 ;
8610   Dali::Degree *result = 0 ;
8611
8612   arg1 = (float)jarg1;
8613   {
8614     try {
8615       result = (Dali::Degree *)new Dali::Degree(arg1);
8616     } catch (std::out_of_range& e) {
8617       {
8618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8619       };
8620     } catch (std::exception& e) {
8621       {
8622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8623       };
8624     } catch (...) {
8625       {
8626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8627       };
8628     }
8629   }
8630   jresult = (void *)result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8636   void * jresult ;
8637   Dali::Radian arg1 ;
8638   Dali::Radian *argp1 ;
8639   Dali::Degree *result = 0 ;
8640
8641   argp1 = (Dali::Radian *)jarg1;
8642   if (!argp1) {
8643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8644     return 0;
8645   }
8646   arg1 = *argp1;
8647   {
8648     try {
8649       result = (Dali::Degree *)new Dali::Degree(arg1);
8650     } catch (std::out_of_range& e) {
8651       {
8652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8653       };
8654     } catch (std::exception& e) {
8655       {
8656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8657       };
8658     } catch (...) {
8659       {
8660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8661       };
8662     }
8663   }
8664   jresult = (void *)result;
8665   return jresult;
8666 }
8667
8668
8669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8670   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8671   float arg2 ;
8672
8673   arg1 = (Dali::Degree *)jarg1;
8674   arg2 = (float)jarg2;
8675   if (arg1) (arg1)->degree = arg2;
8676 }
8677
8678
8679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8680   float jresult ;
8681   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8682   float result;
8683
8684   arg1 = (Dali::Degree *)jarg1;
8685   result = (float) ((arg1)->degree);
8686   jresult = result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8692   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8693
8694   arg1 = (Dali::Degree *)jarg1;
8695   {
8696     try {
8697       delete arg1;
8698     } catch (std::out_of_range& e) {
8699       {
8700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8701       };
8702     } catch (std::exception& e) {
8703       {
8704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8705       };
8706     } catch (...) {
8707       {
8708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8709       };
8710     }
8711   }
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_360;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_315;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8736   void * jresult ;
8737   Dali::Radian *result = 0 ;
8738
8739   result = (Dali::Radian *)&Dali::ANGLE_270;
8740   jresult = (void *)result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8746   void * jresult ;
8747   Dali::Radian *result = 0 ;
8748
8749   result = (Dali::Radian *)&Dali::ANGLE_225;
8750   jresult = (void *)result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8756   void * jresult ;
8757   Dali::Radian *result = 0 ;
8758
8759   result = (Dali::Radian *)&Dali::ANGLE_180;
8760   jresult = (void *)result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8766   void * jresult ;
8767   Dali::Radian *result = 0 ;
8768
8769   result = (Dali::Radian *)&Dali::ANGLE_135;
8770   jresult = (void *)result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8776   void * jresult ;
8777   Dali::Radian *result = 0 ;
8778
8779   result = (Dali::Radian *)&Dali::ANGLE_120;
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8786   void * jresult ;
8787   Dali::Radian *result = 0 ;
8788
8789   result = (Dali::Radian *)&Dali::ANGLE_90;
8790   jresult = (void *)result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8796   void * jresult ;
8797   Dali::Radian *result = 0 ;
8798
8799   result = (Dali::Radian *)&Dali::ANGLE_60;
8800   jresult = (void *)result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8806   void * jresult ;
8807   Dali::Radian *result = 0 ;
8808
8809   result = (Dali::Radian *)&Dali::ANGLE_45;
8810   jresult = (void *)result;
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8816   void * jresult ;
8817   Dali::Radian *result = 0 ;
8818
8819   result = (Dali::Radian *)&Dali::ANGLE_30;
8820   jresult = (void *)result;
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8826   void * jresult ;
8827   Dali::Radian *result = 0 ;
8828
8829   result = (Dali::Radian *)&Dali::ANGLE_0;
8830   jresult = (void *)result;
8831   return jresult;
8832 }
8833
8834
8835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8836   unsigned int jresult ;
8837   Dali::Degree *arg1 = 0 ;
8838   Dali::Degree *arg2 = 0 ;
8839   bool result;
8840
8841   arg1 = (Dali::Degree *)jarg1;
8842   if (!arg1) {
8843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8844     return 0;
8845   }
8846   arg2 = (Dali::Degree *)jarg2;
8847   if (!arg2) {
8848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8849     return 0;
8850   }
8851   {
8852     try {
8853       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8854     } catch (std::out_of_range& e) {
8855       {
8856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8857       };
8858     } catch (std::exception& e) {
8859       {
8860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (...) {
8863       {
8864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8865       };
8866     }
8867   }
8868   jresult = result;
8869   return jresult;
8870 }
8871
8872
8873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8874   unsigned int jresult ;
8875   Dali::Degree *arg1 = 0 ;
8876   Dali::Degree *arg2 = 0 ;
8877   bool result;
8878
8879   arg1 = (Dali::Degree *)jarg1;
8880   if (!arg1) {
8881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8882     return 0;
8883   }
8884   arg2 = (Dali::Degree *)jarg2;
8885   if (!arg2) {
8886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8887     return 0;
8888   }
8889   {
8890     try {
8891       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8892     } catch (std::out_of_range& e) {
8893       {
8894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (std::exception& e) {
8897       {
8898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906   jresult = result;
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8912   void * jresult ;
8913   Dali::Degree arg1 ;
8914   float arg2 ;
8915   float arg3 ;
8916   Dali::Degree *argp1 ;
8917   Dali::Degree result;
8918
8919   argp1 = (Dali::Degree *)jarg1;
8920   if (!argp1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8922     return 0;
8923   }
8924   arg1 = *argp1;
8925   arg2 = (float)jarg2;
8926   arg3 = (float)jarg3;
8927   {
8928     try {
8929       result = Dali::Clamp(arg1,arg2,arg3);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (...) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8941       };
8942     }
8943   }
8944   jresult = new Dali::Degree((const Dali::Degree &)result);
8945   return jresult;
8946 }
8947
8948
8949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8950   void * jresult ;
8951   Dali::Radian *result = 0 ;
8952
8953   {
8954     try {
8955       result = (Dali::Radian *)new Dali::Radian();
8956     } catch (std::out_of_range& e) {
8957       {
8958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8959       };
8960     } catch (std::exception& e) {
8961       {
8962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8963       };
8964     } catch (...) {
8965       {
8966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8967       };
8968     }
8969   }
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8976   void * jresult ;
8977   float arg1 ;
8978   Dali::Radian *result = 0 ;
8979
8980   arg1 = (float)jarg1;
8981   {
8982     try {
8983       result = (Dali::Radian *)new Dali::Radian(arg1);
8984     } catch (std::out_of_range& e) {
8985       {
8986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8987       };
8988     } catch (std::exception& e) {
8989       {
8990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8991       };
8992     } catch (...) {
8993       {
8994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8995       };
8996     }
8997   }
8998   jresult = (void *)result;
8999   return jresult;
9000 }
9001
9002
9003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9004   void * jresult ;
9005   Dali::Degree arg1 ;
9006   Dali::Degree *argp1 ;
9007   Dali::Radian *result = 0 ;
9008
9009   argp1 = (Dali::Degree *)jarg1;
9010   if (!argp1) {
9011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9012     return 0;
9013   }
9014   arg1 = *argp1;
9015   {
9016     try {
9017       result = (Dali::Radian *)new Dali::Radian(arg1);
9018     } catch (std::out_of_range& e) {
9019       {
9020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9021       };
9022     } catch (std::exception& e) {
9023       {
9024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9025       };
9026     } catch (...) {
9027       {
9028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9029       };
9030     }
9031   }
9032   jresult = (void *)result;
9033   return jresult;
9034 }
9035
9036
9037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9038   void * jresult ;
9039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9040   float arg2 ;
9041   Dali::Radian *result = 0 ;
9042
9043   arg1 = (Dali::Radian *)jarg1;
9044   arg2 = (float)jarg2;
9045   {
9046     try {
9047       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9048     } catch (std::out_of_range& e) {
9049       {
9050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9051       };
9052     } catch (std::exception& e) {
9053       {
9054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9055       };
9056     } catch (...) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9059       };
9060     }
9061   }
9062   jresult = (void *)result;
9063   return jresult;
9064 }
9065
9066
9067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9068   void * jresult ;
9069   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9070   Dali::Degree arg2 ;
9071   Dali::Degree *argp2 ;
9072   Dali::Radian *result = 0 ;
9073
9074   arg1 = (Dali::Radian *)jarg1;
9075   argp2 = (Dali::Degree *)jarg2;
9076   if (!argp2) {
9077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9078     return 0;
9079   }
9080   arg2 = *argp2;
9081   {
9082     try {
9083       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9084     } catch (std::out_of_range& e) {
9085       {
9086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9087       };
9088     } catch (std::exception& e) {
9089       {
9090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9091       };
9092     } catch (...) {
9093       {
9094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9095       };
9096     }
9097   }
9098   jresult = (void *)result;
9099   return jresult;
9100 }
9101
9102
9103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9104   float jresult ;
9105   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9106   float result;
9107
9108   arg1 = (Dali::Radian *)jarg1;
9109   {
9110     try {
9111       result = (float)((Dali::Radian const *)arg1)->operator float();
9112     } catch (std::out_of_range& e) {
9113       {
9114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9115       };
9116     } catch (std::exception& e) {
9117       {
9118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9119       };
9120     } catch (...) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9123       };
9124     }
9125   }
9126   jresult = result;
9127   return jresult;
9128 }
9129
9130
9131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9133   float arg2 ;
9134
9135   arg1 = (Dali::Radian *)jarg1;
9136   arg2 = (float)jarg2;
9137   if (arg1) (arg1)->radian = arg2;
9138 }
9139
9140
9141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9142   float jresult ;
9143   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9144   float result;
9145
9146   arg1 = (Dali::Radian *)jarg1;
9147   result = (float) ((arg1)->radian);
9148   jresult = result;
9149   return jresult;
9150 }
9151
9152
9153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9155
9156   arg1 = (Dali::Radian *)jarg1;
9157   {
9158     try {
9159       delete arg1;
9160     } catch (std::out_of_range& e) {
9161       {
9162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9163       };
9164     } catch (std::exception& e) {
9165       {
9166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9167       };
9168     } catch (...) {
9169       {
9170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9171       };
9172     }
9173   }
9174 }
9175
9176
9177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9178   unsigned int jresult ;
9179   Dali::Radian arg1 ;
9180   Dali::Radian arg2 ;
9181   Dali::Radian *argp1 ;
9182   Dali::Radian *argp2 ;
9183   bool result;
9184
9185   argp1 = (Dali::Radian *)jarg1;
9186   if (!argp1) {
9187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9188     return 0;
9189   }
9190   arg1 = *argp1;
9191   argp2 = (Dali::Radian *)jarg2;
9192   if (!argp2) {
9193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9194     return 0;
9195   }
9196   arg2 = *argp2;
9197   {
9198     try {
9199       result = (bool)Dali::operator ==(arg1,arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9207       };
9208     } catch (...) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9211       };
9212     }
9213   }
9214   jresult = result;
9215   return jresult;
9216 }
9217
9218
9219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9220   unsigned int jresult ;
9221   Dali::Radian arg1 ;
9222   Dali::Radian arg2 ;
9223   Dali::Radian *argp1 ;
9224   Dali::Radian *argp2 ;
9225   bool result;
9226
9227   argp1 = (Dali::Radian *)jarg1;
9228   if (!argp1) {
9229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9230     return 0;
9231   }
9232   arg1 = *argp1;
9233   argp2 = (Dali::Radian *)jarg2;
9234   if (!argp2) {
9235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9236     return 0;
9237   }
9238   arg2 = *argp2;
9239   {
9240     try {
9241       result = (bool)Dali::operator !=(arg1,arg2);
9242     } catch (std::out_of_range& e) {
9243       {
9244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9245       };
9246     } catch (std::exception& e) {
9247       {
9248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (...) {
9251       {
9252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9253       };
9254     }
9255   }
9256   jresult = result;
9257   return jresult;
9258 }
9259
9260
9261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9262   unsigned int jresult ;
9263   Dali::Radian arg1 ;
9264   Dali::Degree arg2 ;
9265   Dali::Radian *argp1 ;
9266   Dali::Degree *argp2 ;
9267   bool result;
9268
9269   argp1 = (Dali::Radian *)jarg1;
9270   if (!argp1) {
9271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9272     return 0;
9273   }
9274   arg1 = *argp1;
9275   argp2 = (Dali::Degree *)jarg2;
9276   if (!argp2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9278     return 0;
9279   }
9280   arg2 = *argp2;
9281   {
9282     try {
9283       result = (bool)Dali::operator ==(arg1,arg2);
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (...) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9295       };
9296     }
9297   }
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9304   unsigned int jresult ;
9305   Dali::Radian arg1 ;
9306   Dali::Degree arg2 ;
9307   Dali::Radian *argp1 ;
9308   Dali::Degree *argp2 ;
9309   bool result;
9310
9311   argp1 = (Dali::Radian *)jarg1;
9312   if (!argp1) {
9313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9314     return 0;
9315   }
9316   arg1 = *argp1;
9317   argp2 = (Dali::Degree *)jarg2;
9318   if (!argp2) {
9319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9320     return 0;
9321   }
9322   arg2 = *argp2;
9323   {
9324     try {
9325       result = (bool)Dali::operator !=(arg1,arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (...) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9337       };
9338     }
9339   }
9340   jresult = result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Degree arg1 ;
9348   Dali::Radian arg2 ;
9349   Dali::Degree *argp1 ;
9350   Dali::Radian *argp2 ;
9351   bool result;
9352
9353   argp1 = (Dali::Degree *)jarg1;
9354   if (!argp1) {
9355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9356     return 0;
9357   }
9358   arg1 = *argp1;
9359   argp2 = (Dali::Radian *)jarg2;
9360   if (!argp2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9362     return 0;
9363   }
9364   arg2 = *argp2;
9365   {
9366     try {
9367       result = (bool)Dali::operator ==(arg1,arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (...) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9379       };
9380     }
9381   }
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Degree arg1 ;
9390   Dali::Radian arg2 ;
9391   Dali::Degree *argp1 ;
9392   Dali::Radian *argp2 ;
9393   bool result;
9394
9395   argp1 = (Dali::Degree *)jarg1;
9396   if (!argp1) {
9397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9398     return 0;
9399   }
9400   arg1 = *argp1;
9401   argp2 = (Dali::Radian *)jarg2;
9402   if (!argp2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9404     return 0;
9405   }
9406   arg2 = *argp2;
9407   {
9408     try {
9409       result = (bool)Dali::operator !=(arg1,arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9430   unsigned int jresult ;
9431   Dali::Radian arg1 ;
9432   Dali::Radian arg2 ;
9433   Dali::Radian *argp1 ;
9434   Dali::Radian *argp2 ;
9435   bool result;
9436
9437   argp1 = (Dali::Radian *)jarg1;
9438   if (!argp1) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9440     return 0;
9441   }
9442   arg1 = *argp1;
9443   argp2 = (Dali::Radian *)jarg2;
9444   if (!argp2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9446     return 0;
9447   }
9448   arg2 = *argp2;
9449   {
9450     try {
9451       result = (bool)Dali::operator >(arg1,arg2);
9452     } catch (std::out_of_range& e) {
9453       {
9454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (std::exception& e) {
9457       {
9458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466   jresult = result;
9467   return jresult;
9468 }
9469
9470
9471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9472   unsigned int jresult ;
9473   Dali::Radian arg1 ;
9474   Dali::Degree arg2 ;
9475   Dali::Radian *argp1 ;
9476   Dali::Degree *argp2 ;
9477   bool result;
9478
9479   argp1 = (Dali::Radian *)jarg1;
9480   if (!argp1) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9482     return 0;
9483   }
9484   arg1 = *argp1;
9485   argp2 = (Dali::Degree *)jarg2;
9486   if (!argp2) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9488     return 0;
9489   }
9490   arg2 = *argp2;
9491   {
9492     try {
9493       result = (bool)Dali::operator >(arg1,arg2);
9494     } catch (std::out_of_range& e) {
9495       {
9496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (std::exception& e) {
9499       {
9500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508   jresult = result;
9509   return jresult;
9510 }
9511
9512
9513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9514   unsigned int jresult ;
9515   Dali::Degree arg1 ;
9516   Dali::Radian arg2 ;
9517   Dali::Degree *argp1 ;
9518   Dali::Radian *argp2 ;
9519   bool result;
9520
9521   argp1 = (Dali::Degree *)jarg1;
9522   if (!argp1) {
9523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9524     return 0;
9525   }
9526   arg1 = *argp1;
9527   argp2 = (Dali::Radian *)jarg2;
9528   if (!argp2) {
9529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9530     return 0;
9531   }
9532   arg2 = *argp2;
9533   {
9534     try {
9535       result = (bool)Dali::operator >(arg1,arg2);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9547       };
9548     }
9549   }
9550   jresult = result;
9551   return jresult;
9552 }
9553
9554
9555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9556   unsigned int jresult ;
9557   Dali::Radian arg1 ;
9558   Dali::Radian arg2 ;
9559   Dali::Radian *argp1 ;
9560   Dali::Radian *argp2 ;
9561   bool result;
9562
9563   argp1 = (Dali::Radian *)jarg1;
9564   if (!argp1) {
9565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9566     return 0;
9567   }
9568   arg1 = *argp1;
9569   argp2 = (Dali::Radian *)jarg2;
9570   if (!argp2) {
9571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9572     return 0;
9573   }
9574   arg2 = *argp2;
9575   {
9576     try {
9577       result = (bool)Dali::operator <(arg1,arg2);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (...) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9589       };
9590     }
9591   }
9592   jresult = result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9598   unsigned int jresult ;
9599   Dali::Radian arg1 ;
9600   Dali::Degree arg2 ;
9601   Dali::Radian *argp1 ;
9602   Dali::Degree *argp2 ;
9603   bool result;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   argp2 = (Dali::Degree *)jarg2;
9612   if (!argp2) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9614     return 0;
9615   }
9616   arg2 = *argp2;
9617   {
9618     try {
9619       result = (bool)Dali::operator <(arg1,arg2);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (...) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9631       };
9632     }
9633   }
9634   jresult = result;
9635   return jresult;
9636 }
9637
9638
9639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9640   unsigned int jresult ;
9641   Dali::Degree arg1 ;
9642   Dali::Radian arg2 ;
9643   Dali::Degree *argp1 ;
9644   Dali::Radian *argp2 ;
9645   bool result;
9646
9647   argp1 = (Dali::Degree *)jarg1;
9648   if (!argp1) {
9649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9650     return 0;
9651   }
9652   arg1 = *argp1;
9653   argp2 = (Dali::Radian *)jarg2;
9654   if (!argp2) {
9655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9656     return 0;
9657   }
9658   arg2 = *argp2;
9659   {
9660     try {
9661       result = (bool)Dali::operator <(arg1,arg2);
9662     } catch (std::out_of_range& e) {
9663       {
9664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9665       };
9666     } catch (std::exception& e) {
9667       {
9668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9669       };
9670     } catch (...) {
9671       {
9672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9673       };
9674     }
9675   }
9676   jresult = result;
9677   return jresult;
9678 }
9679
9680
9681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9682   void * jresult ;
9683   Dali::Radian arg1 ;
9684   float arg2 ;
9685   Dali::Radian *argp1 ;
9686   Dali::Radian result;
9687
9688   argp1 = (Dali::Radian *)jarg1;
9689   if (!argp1) {
9690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9691     return 0;
9692   }
9693   arg1 = *argp1;
9694   arg2 = (float)jarg2;
9695   {
9696     try {
9697       result = Dali::operator *(arg1,arg2);
9698     } catch (std::out_of_range& e) {
9699       {
9700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (std::exception& e) {
9703       {
9704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9705       };
9706     } catch (...) {
9707       {
9708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9709       };
9710     }
9711   }
9712   jresult = new Dali::Radian((const Dali::Radian &)result);
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9718   void * jresult ;
9719   Dali::Radian arg1 ;
9720   Dali::Radian *argp1 ;
9721   Dali::Radian result;
9722
9723   argp1 = (Dali::Radian *)jarg1;
9724   if (!argp1) {
9725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9726     return 0;
9727   }
9728   arg1 = *argp1;
9729   {
9730     try {
9731       result = Dali::operator -(arg1);
9732     } catch (std::out_of_range& e) {
9733       {
9734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9735       };
9736     } catch (std::exception& e) {
9737       {
9738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (...) {
9741       {
9742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9743       };
9744     }
9745   }
9746   jresult = new Dali::Radian((const Dali::Radian &)result);
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9752   void * jresult ;
9753   Dali::Radian arg1 ;
9754   float arg2 ;
9755   float arg3 ;
9756   Dali::Radian *argp1 ;
9757   Dali::Radian result;
9758
9759   argp1 = (Dali::Radian *)jarg1;
9760   if (!argp1) {
9761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9762     return 0;
9763   }
9764   arg1 = *argp1;
9765   arg2 = (float)jarg2;
9766   arg3 = (float)jarg3;
9767   {
9768     try {
9769       result = Dali::Clamp(arg1,arg2,arg3);
9770     } catch (std::out_of_range& e) {
9771       {
9772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9773       };
9774     } catch (std::exception& e) {
9775       {
9776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9777       };
9778     } catch (...) {
9779       {
9780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9781       };
9782     }
9783   }
9784   jresult = new Dali::Radian((const Dali::Radian &)result);
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9790   void * jresult ;
9791   Dali::Quaternion *result = 0 ;
9792
9793   {
9794     try {
9795       result = (Dali::Quaternion *)new Dali::Quaternion();
9796     } catch (std::out_of_range& e) {
9797       {
9798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9799       };
9800     } catch (std::exception& e) {
9801       {
9802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9803       };
9804     } catch (...) {
9805       {
9806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9807       };
9808     }
9809   }
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9816   void * jresult ;
9817   Dali::Radian arg1 ;
9818   Dali::Vector3 *arg2 = 0 ;
9819   Dali::Radian *argp1 ;
9820   Dali::Quaternion *result = 0 ;
9821
9822   argp1 = (Dali::Radian *)jarg1;
9823   if (!argp1) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9825     return 0;
9826   }
9827   arg1 = *argp1;
9828   arg2 = (Dali::Vector3 *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850   jresult = (void *)result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9856   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9857
9858   arg1 = (Dali::Quaternion *)jarg1;
9859   {
9860     try {
9861       delete arg1;
9862     } catch (std::out_of_range& e) {
9863       {
9864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9865       };
9866     } catch (std::exception& e) {
9867       {
9868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9869       };
9870     } catch (...) {
9871       {
9872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9873       };
9874     }
9875   }
9876 }
9877
9878
9879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9880   void * jresult ;
9881   Dali::Quaternion *result = 0 ;
9882
9883   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9884   jresult = (void *)result;
9885   return jresult;
9886 }
9887
9888
9889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9890   unsigned int jresult ;
9891   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9892   bool result;
9893
9894   arg1 = (Dali::Quaternion *)jarg1;
9895   {
9896     try {
9897       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9898     } catch (std::out_of_range& e) {
9899       {
9900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9901       };
9902     } catch (std::exception& e) {
9903       {
9904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9905       };
9906     } catch (...) {
9907       {
9908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9909       };
9910     }
9911   }
9912   jresult = result;
9913   return jresult;
9914 }
9915
9916
9917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9918   unsigned int jresult ;
9919   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9920   Dali::Vector3 *arg2 = 0 ;
9921   Dali::Radian *arg3 = 0 ;
9922   bool result;
9923
9924   arg1 = (Dali::Quaternion *)jarg1;
9925   arg2 = (Dali::Vector3 *)jarg2;
9926   if (!arg2) {
9927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9928     return 0;
9929   }
9930   arg3 = (Dali::Radian *)jarg3;
9931   if (!arg3) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9938     } catch (std::out_of_range& e) {
9939       {
9940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (std::exception& e) {
9943       {
9944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9945       };
9946     } catch (...) {
9947       {
9948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9949       };
9950     }
9951   }
9952   jresult = result;
9953   return jresult;
9954 }
9955
9956
9957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9958   void * jresult ;
9959   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9960   Dali::Quaternion *arg2 = 0 ;
9961   Dali::Quaternion result;
9962
9963   arg1 = (Dali::Quaternion *)jarg1;
9964   arg2 = (Dali::Quaternion *)jarg2;
9965   if (!arg2) {
9966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9967     return 0;
9968   }
9969   {
9970     try {
9971       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9972     } catch (std::out_of_range& e) {
9973       {
9974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9975       };
9976     } catch (std::exception& e) {
9977       {
9978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (...) {
9981       {
9982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9983       };
9984     }
9985   }
9986   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9992   void * jresult ;
9993   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9994   Dali::Quaternion *arg2 = 0 ;
9995   Dali::Quaternion result;
9996
9997   arg1 = (Dali::Quaternion *)jarg1;
9998   arg2 = (Dali::Quaternion *)jarg2;
9999   if (!arg2) {
10000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10001     return 0;
10002   }
10003   {
10004     try {
10005       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10006     } catch (std::out_of_range& e) {
10007       {
10008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10009       };
10010     } catch (std::exception& e) {
10011       {
10012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10013       };
10014     } catch (...) {
10015       {
10016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10017       };
10018     }
10019   }
10020   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10026   void * jresult ;
10027   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10028   Dali::Quaternion *arg2 = 0 ;
10029   Dali::Quaternion result;
10030
10031   arg1 = (Dali::Quaternion *)jarg1;
10032   arg2 = (Dali::Quaternion *)jarg2;
10033   if (!arg2) {
10034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10035     return 0;
10036   }
10037   {
10038     try {
10039       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10040     } catch (std::out_of_range& e) {
10041       {
10042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (std::exception& e) {
10045       {
10046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10047       };
10048     } catch (...) {
10049       {
10050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10051       };
10052     }
10053   }
10054   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10055   return jresult;
10056 }
10057
10058
10059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10060   void * jresult ;
10061   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10062   Dali::Vector3 *arg2 = 0 ;
10063   Dali::Vector3 result;
10064
10065   arg1 = (Dali::Quaternion *)jarg1;
10066   arg2 = (Dali::Vector3 *)jarg2;
10067   if (!arg2) {
10068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10069     return 0;
10070   }
10071   {
10072     try {
10073       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10074     } catch (std::out_of_range& e) {
10075       {
10076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10077       };
10078     } catch (std::exception& e) {
10079       {
10080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10081       };
10082     } catch (...) {
10083       {
10084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10085       };
10086     }
10087   }
10088   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10089   return jresult;
10090 }
10091
10092
10093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10094   void * jresult ;
10095   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10096   Dali::Quaternion *arg2 = 0 ;
10097   Dali::Quaternion result;
10098
10099   arg1 = (Dali::Quaternion *)jarg1;
10100   arg2 = (Dali::Quaternion *)jarg2;
10101   if (!arg2) {
10102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10103     return 0;
10104   }
10105   {
10106     try {
10107       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10108     } catch (std::out_of_range& e) {
10109       {
10110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10111       };
10112     } catch (std::exception& e) {
10113       {
10114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10115       };
10116     } catch (...) {
10117       {
10118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10119       };
10120     }
10121   }
10122   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10123   return jresult;
10124 }
10125
10126
10127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10128   void * jresult ;
10129   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10130   float arg2 ;
10131   Dali::Quaternion result;
10132
10133   arg1 = (Dali::Quaternion *)jarg1;
10134   arg2 = (float)jarg2;
10135   {
10136     try {
10137       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10138     } catch (std::out_of_range& e) {
10139       {
10140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (std::exception& e) {
10143       {
10144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10158   void * jresult ;
10159   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10160   float arg2 ;
10161   Dali::Quaternion result;
10162
10163   arg1 = (Dali::Quaternion *)jarg1;
10164   arg2 = (float)jarg2;
10165   {
10166     try {
10167       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10168     } catch (std::out_of_range& e) {
10169       {
10170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10171       };
10172     } catch (std::exception& e) {
10173       {
10174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10175       };
10176     } catch (...) {
10177       {
10178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10179       };
10180     }
10181   }
10182   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10183   return jresult;
10184 }
10185
10186
10187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10188   void * jresult ;
10189   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10190   Dali::Quaternion result;
10191
10192   arg1 = (Dali::Quaternion *)jarg1;
10193   {
10194     try {
10195       result = ((Dali::Quaternion const *)arg1)->operator -();
10196     } catch (std::out_of_range& e) {
10197       {
10198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (std::exception& e) {
10201       {
10202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10207       };
10208     }
10209   }
10210   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10216   void * jresult ;
10217   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10218   Dali::Quaternion *arg2 = 0 ;
10219   Dali::Quaternion *result = 0 ;
10220
10221   arg1 = (Dali::Quaternion *)jarg1;
10222   arg2 = (Dali::Quaternion *)jarg2;
10223   if (!arg2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10225     return 0;
10226   }
10227   {
10228     try {
10229       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (...) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10241       };
10242     }
10243   }
10244   jresult = (void *)result;
10245   return jresult;
10246 }
10247
10248
10249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10250   void * jresult ;
10251   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10252   Dali::Quaternion *arg2 = 0 ;
10253   Dali::Quaternion *result = 0 ;
10254
10255   arg1 = (Dali::Quaternion *)jarg1;
10256   arg2 = (Dali::Quaternion *)jarg2;
10257   if (!arg2) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10259     return 0;
10260   }
10261   {
10262     try {
10263       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10264     } catch (std::out_of_range& e) {
10265       {
10266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10267       };
10268     } catch (std::exception& e) {
10269       {
10270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10271       };
10272     } catch (...) {
10273       {
10274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10275       };
10276     }
10277   }
10278   jresult = (void *)result;
10279   return jresult;
10280 }
10281
10282
10283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10284   void * jresult ;
10285   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10286   Dali::Quaternion *arg2 = 0 ;
10287   Dali::Quaternion *result = 0 ;
10288
10289   arg1 = (Dali::Quaternion *)jarg1;
10290   arg2 = (Dali::Quaternion *)jarg2;
10291   if (!arg2) {
10292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10293     return 0;
10294   }
10295   {
10296     try {
10297       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10298     } catch (std::out_of_range& e) {
10299       {
10300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10301       };
10302     } catch (std::exception& e) {
10303       {
10304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10305       };
10306     } catch (...) {
10307       {
10308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10309       };
10310     }
10311   }
10312   jresult = (void *)result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10318   void * jresult ;
10319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10320   float arg2 ;
10321   Dali::Quaternion *result = 0 ;
10322
10323   arg1 = (Dali::Quaternion *)jarg1;
10324   arg2 = (float)jarg2;
10325   {
10326     try {
10327       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10328     } catch (std::out_of_range& e) {
10329       {
10330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (std::exception& e) {
10333       {
10334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342   jresult = (void *)result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10348   void * jresult ;
10349   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10350   float arg2 ;
10351   Dali::Quaternion *result = 0 ;
10352
10353   arg1 = (Dali::Quaternion *)jarg1;
10354   arg2 = (float)jarg2;
10355   {
10356     try {
10357       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10358     } catch (std::out_of_range& e) {
10359       {
10360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (std::exception& e) {
10363       {
10364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10365       };
10366     } catch (...) {
10367       {
10368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10369       };
10370     }
10371   }
10372   jresult = (void *)result;
10373   return jresult;
10374 }
10375
10376
10377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10378   unsigned int jresult ;
10379   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10380   Dali::Quaternion *arg2 = 0 ;
10381   bool result;
10382
10383   arg1 = (Dali::Quaternion *)jarg1;
10384   arg2 = (Dali::Quaternion *)jarg2;
10385   if (!arg2) {
10386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10387     return 0;
10388   }
10389   {
10390     try {
10391       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10392     } catch (std::out_of_range& e) {
10393       {
10394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10395       };
10396     } catch (std::exception& e) {
10397       {
10398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10399       };
10400     } catch (...) {
10401       {
10402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10403       };
10404     }
10405   }
10406   jresult = result;
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10412   unsigned int jresult ;
10413   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10414   Dali::Quaternion *arg2 = 0 ;
10415   bool result;
10416
10417   arg1 = (Dali::Quaternion *)jarg1;
10418   arg2 = (Dali::Quaternion *)jarg2;
10419   if (!arg2) {
10420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10421     return 0;
10422   }
10423   {
10424     try {
10425       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10426     } catch (std::out_of_range& e) {
10427       {
10428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10429       };
10430     } catch (std::exception& e) {
10431       {
10432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10433       };
10434     } catch (...) {
10435       {
10436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10437       };
10438     }
10439   }
10440   jresult = result;
10441   return jresult;
10442 }
10443
10444
10445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10446   float jresult ;
10447   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10448   float result;
10449
10450   arg1 = (Dali::Quaternion *)jarg1;
10451   {
10452     try {
10453       result = (float)((Dali::Quaternion const *)arg1)->Length();
10454     } catch (std::out_of_range& e) {
10455       {
10456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (std::exception& e) {
10459       {
10460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (...) {
10463       {
10464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10465       };
10466     }
10467   }
10468   jresult = result;
10469   return jresult;
10470 }
10471
10472
10473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10474   float jresult ;
10475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10476   float result;
10477
10478   arg1 = (Dali::Quaternion *)jarg1;
10479   {
10480     try {
10481       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10482     } catch (std::out_of_range& e) {
10483       {
10484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10485       };
10486     } catch (std::exception& e) {
10487       {
10488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10489       };
10490     } catch (...) {
10491       {
10492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10493       };
10494     }
10495   }
10496   jresult = result;
10497   return jresult;
10498 }
10499
10500
10501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503
10504   arg1 = (Dali::Quaternion *)jarg1;
10505   {
10506     try {
10507       (arg1)->Normalize();
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10515       };
10516     } catch (...) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10519       };
10520     }
10521   }
10522 }
10523
10524
10525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10526   void * jresult ;
10527   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10528   Dali::Quaternion result;
10529
10530   arg1 = (Dali::Quaternion *)jarg1;
10531   {
10532     try {
10533       result = ((Dali::Quaternion const *)arg1)->Normalized();
10534     } catch (std::out_of_range& e) {
10535       {
10536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10537       };
10538     } catch (std::exception& e) {
10539       {
10540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10541       };
10542     } catch (...) {
10543       {
10544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10545       };
10546     }
10547   }
10548   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10549   return jresult;
10550 }
10551
10552
10553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10554   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10555
10556   arg1 = (Dali::Quaternion *)jarg1;
10557   {
10558     try {
10559       (arg1)->Conjugate();
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10571       };
10572     }
10573   }
10574 }
10575
10576
10577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10578   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10579
10580   arg1 = (Dali::Quaternion *)jarg1;
10581   {
10582     try {
10583       (arg1)->Invert();
10584     } catch (std::out_of_range& e) {
10585       {
10586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10587       };
10588     } catch (std::exception& e) {
10589       {
10590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10591       };
10592     } catch (...) {
10593       {
10594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10595       };
10596     }
10597   }
10598 }
10599
10600
10601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10602   void * jresult ;
10603   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10604   Dali::Quaternion result;
10605
10606   arg1 = (Dali::Quaternion *)jarg1;
10607   {
10608     try {
10609       result = ((Dali::Quaternion const *)arg1)->Log();
10610     } catch (std::out_of_range& e) {
10611       {
10612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (std::exception& e) {
10615       {
10616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10630   void * jresult ;
10631   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10632   Dali::Quaternion result;
10633
10634   arg1 = (Dali::Quaternion *)jarg1;
10635   {
10636     try {
10637       result = ((Dali::Quaternion const *)arg1)->Exp();
10638     } catch (std::out_of_range& e) {
10639       {
10640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (std::exception& e) {
10643       {
10644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (...) {
10647       {
10648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10649       };
10650     }
10651   }
10652   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10653   return jresult;
10654 }
10655
10656
10657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10658   float jresult ;
10659   Dali::Quaternion *arg1 = 0 ;
10660   Dali::Quaternion *arg2 = 0 ;
10661   float result;
10662
10663   arg1 = (Dali::Quaternion *)jarg1;
10664   if (!arg1) {
10665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10666     return 0;
10667   }
10668   arg2 = (Dali::Quaternion *)jarg2;
10669   if (!arg2) {
10670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10671     return 0;
10672   }
10673   {
10674     try {
10675       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10676     } catch (std::out_of_range& e) {
10677       {
10678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10679       };
10680     } catch (std::exception& e) {
10681       {
10682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10683       };
10684     } catch (...) {
10685       {
10686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10687       };
10688     }
10689   }
10690   jresult = result;
10691   return jresult;
10692 }
10693
10694
10695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10696   void * jresult ;
10697   Dali::Quaternion *arg1 = 0 ;
10698   Dali::Quaternion *arg2 = 0 ;
10699   float arg3 ;
10700   Dali::Quaternion result;
10701
10702   arg1 = (Dali::Quaternion *)jarg1;
10703   if (!arg1) {
10704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10705     return 0;
10706   }
10707   arg2 = (Dali::Quaternion *)jarg2;
10708   if (!arg2) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10710     return 0;
10711   }
10712   arg3 = (float)jarg3;
10713   {
10714     try {
10715       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10716     } catch (std::out_of_range& e) {
10717       {
10718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (std::exception& e) {
10721       {
10722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10723       };
10724     } catch (...) {
10725       {
10726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10727       };
10728     }
10729   }
10730   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10731   return jresult;
10732 }
10733
10734
10735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10736   void * jresult ;
10737   Dali::Quaternion *arg1 = 0 ;
10738   Dali::Quaternion *arg2 = 0 ;
10739   float arg3 ;
10740   Dali::Quaternion result;
10741
10742   arg1 = (Dali::Quaternion *)jarg1;
10743   if (!arg1) {
10744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10745     return 0;
10746   }
10747   arg2 = (Dali::Quaternion *)jarg2;
10748   if (!arg2) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10750     return 0;
10751   }
10752   arg3 = (float)jarg3;
10753   {
10754     try {
10755       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10756     } catch (std::out_of_range& e) {
10757       {
10758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10759       };
10760     } catch (std::exception& e) {
10761       {
10762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10763       };
10764     } catch (...) {
10765       {
10766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10767       };
10768     }
10769   }
10770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10771   return jresult;
10772 }
10773
10774
10775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10776   void * jresult ;
10777   Dali::Quaternion *arg1 = 0 ;
10778   Dali::Quaternion *arg2 = 0 ;
10779   float arg3 ;
10780   Dali::Quaternion result;
10781
10782   arg1 = (Dali::Quaternion *)jarg1;
10783   if (!arg1) {
10784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10785     return 0;
10786   }
10787   arg2 = (Dali::Quaternion *)jarg2;
10788   if (!arg2) {
10789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10790     return 0;
10791   }
10792   arg3 = (float)jarg3;
10793   {
10794     try {
10795       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10803       };
10804     } catch (...) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10807       };
10808     }
10809   }
10810   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10811   return jresult;
10812 }
10813
10814
10815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10816   void * jresult ;
10817   Dali::Quaternion *arg1 = 0 ;
10818   Dali::Quaternion *arg2 = 0 ;
10819   Dali::Quaternion *arg3 = 0 ;
10820   Dali::Quaternion *arg4 = 0 ;
10821   float arg5 ;
10822   Dali::Quaternion result;
10823
10824   arg1 = (Dali::Quaternion *)jarg1;
10825   if (!arg1) {
10826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10827     return 0;
10828   }
10829   arg2 = (Dali::Quaternion *)jarg2;
10830   if (!arg2) {
10831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10832     return 0;
10833   }
10834   arg3 = (Dali::Quaternion *)jarg3;
10835   if (!arg3) {
10836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10837     return 0;
10838   }
10839   arg4 = (Dali::Quaternion *)jarg4;
10840   if (!arg4) {
10841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10842     return 0;
10843   }
10844   arg5 = (float)jarg5;
10845   {
10846     try {
10847       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10848     } catch (std::out_of_range& e) {
10849       {
10850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10851       };
10852     } catch (std::exception& e) {
10853       {
10854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (...) {
10857       {
10858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10859       };
10860     }
10861   }
10862   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10863   return jresult;
10864 }
10865
10866
10867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10868   float jresult ;
10869   Dali::Quaternion *arg1 = 0 ;
10870   Dali::Quaternion *arg2 = 0 ;
10871   float result;
10872
10873   arg1 = (Dali::Quaternion *)jarg1;
10874   if (!arg1) {
10875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10876     return 0;
10877   }
10878   arg2 = (Dali::Quaternion *)jarg2;
10879   if (!arg2) {
10880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10881     return 0;
10882   }
10883   {
10884     try {
10885       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10886     } catch (std::out_of_range& e) {
10887       {
10888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10889       };
10890     } catch (std::exception& e) {
10891       {
10892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (...) {
10895       {
10896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10897       };
10898     }
10899   }
10900   jresult = result;
10901   return jresult;
10902 }
10903
10904
10905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10906   void * jresult ;
10907   Dali::Matrix *result = 0 ;
10908
10909   {
10910     try {
10911       result = (Dali::Matrix *)new Dali::Matrix();
10912     } catch (std::out_of_range& e) {
10913       {
10914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (std::exception& e) {
10917       {
10918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10923       };
10924     }
10925   }
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10932   void * jresult ;
10933   bool arg1 ;
10934   Dali::Matrix *result = 0 ;
10935
10936   arg1 = jarg1 ? true : false;
10937   {
10938     try {
10939       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10940     } catch (std::out_of_range& e) {
10941       {
10942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10943       };
10944     } catch (std::exception& e) {
10945       {
10946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (...) {
10949       {
10950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10951       };
10952     }
10953   }
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10960   void * jresult ;
10961   float *arg1 = (float *) 0 ;
10962   Dali::Matrix *result = 0 ;
10963
10964   arg1 = jarg1;
10965   {
10966     try {
10967       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10968     } catch (std::out_of_range& e) {
10969       {
10970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (std::exception& e) {
10973       {
10974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10975       };
10976     } catch (...) {
10977       {
10978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10979       };
10980     }
10981   }
10982   jresult = (void *)result;
10983
10984
10985   return jresult;
10986 }
10987
10988
10989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10990   void * jresult ;
10991   Dali::Quaternion *arg1 = 0 ;
10992   Dali::Matrix *result = 0 ;
10993
10994   arg1 = (Dali::Quaternion *)jarg1;
10995   if (!arg1) {
10996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10997     return 0;
10998   }
10999   {
11000     try {
11001       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11002     } catch (std::out_of_range& e) {
11003       {
11004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11005       };
11006     } catch (std::exception& e) {
11007       {
11008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11009       };
11010     } catch (...) {
11011       {
11012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11013       };
11014     }
11015   }
11016   jresult = (void *)result;
11017   return jresult;
11018 }
11019
11020
11021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11022   void * jresult ;
11023   Dali::Matrix *arg1 = 0 ;
11024   Dali::Matrix *result = 0 ;
11025
11026   arg1 = (Dali::Matrix *)jarg1;
11027   if (!arg1) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11029     return 0;
11030   }
11031   {
11032     try {
11033       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11045       };
11046     }
11047   }
11048   jresult = (void *)result;
11049   return jresult;
11050 }
11051
11052
11053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11054   void * jresult ;
11055   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11056   Dali::Matrix *arg2 = 0 ;
11057   Dali::Matrix *result = 0 ;
11058
11059   arg1 = (Dali::Matrix *)jarg1;
11060   arg2 = (Dali::Matrix *)jarg2;
11061   if (!arg2) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11068     } catch (std::out_of_range& e) {
11069       {
11070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11071       };
11072     } catch (std::exception& e) {
11073       {
11074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11075       };
11076     } catch (...) {
11077       {
11078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11079       };
11080     }
11081   }
11082   jresult = (void *)result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11088   void * jresult ;
11089   Dali::Matrix *result = 0 ;
11090
11091   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11092   jresult = (void *)result;
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11099
11100   arg1 = (Dali::Matrix *)jarg1;
11101   {
11102     try {
11103       (arg1)->SetIdentity();
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11111       };
11112     } catch (...) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11115       };
11116     }
11117   }
11118 }
11119
11120
11121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11122   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11123   Dali::Vector3 *arg2 = 0 ;
11124
11125   arg1 = (Dali::Matrix *)jarg1;
11126   arg2 = (Dali::Vector3 *)jarg2;
11127   if (!arg2) {
11128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11129     return ;
11130   }
11131   {
11132     try {
11133       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11134     } catch (std::out_of_range& e) {
11135       {
11136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11137       };
11138     } catch (std::exception& e) {
11139       {
11140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11145       };
11146     }
11147   }
11148 }
11149
11150
11151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11152   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11153   Dali::Matrix *arg2 = 0 ;
11154
11155   arg1 = (Dali::Matrix *)jarg1;
11156   arg2 = (Dali::Matrix *)jarg2;
11157   if (!arg2) {
11158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11159     return ;
11160   }
11161   {
11162     try {
11163       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11164     } catch (std::out_of_range& e) {
11165       {
11166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11167       };
11168     } catch (std::exception& e) {
11169       {
11170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11171       };
11172     } catch (...) {
11173       {
11174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11175       };
11176     }
11177   }
11178 }
11179
11180
11181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11182   unsigned int jresult ;
11183   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11184   bool result;
11185
11186   arg1 = (Dali::Matrix *)jarg1;
11187   {
11188     try {
11189       result = (bool)(arg1)->Invert();
11190     } catch (std::out_of_range& e) {
11191       {
11192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11193       };
11194     } catch (std::exception& e) {
11195       {
11196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11197       };
11198     } catch (...) {
11199       {
11200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11201       };
11202     }
11203   }
11204   jresult = result;
11205   return jresult;
11206 }
11207
11208
11209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11210   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11211
11212   arg1 = (Dali::Matrix *)jarg1;
11213   {
11214     try {
11215       (arg1)->Transpose();
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11223       };
11224     } catch (...) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11227       };
11228     }
11229   }
11230 }
11231
11232
11233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11234   void * jresult ;
11235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11236   Dali::Vector3 result;
11237
11238   arg1 = (Dali::Matrix *)jarg1;
11239   {
11240     try {
11241       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11242     } catch (std::out_of_range& e) {
11243       {
11244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11245       };
11246     } catch (std::exception& e) {
11247       {
11248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (...) {
11251       {
11252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11253       };
11254     }
11255   }
11256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11257   return jresult;
11258 }
11259
11260
11261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11262   void * jresult ;
11263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11264   Dali::Vector3 result;
11265
11266   arg1 = (Dali::Matrix *)jarg1;
11267   {
11268     try {
11269       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11270     } catch (std::out_of_range& e) {
11271       {
11272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11273       };
11274     } catch (std::exception& e) {
11275       {
11276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11277       };
11278     } catch (...) {
11279       {
11280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11281       };
11282     }
11283   }
11284   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11290   void * jresult ;
11291   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11292   Dali::Vector3 result;
11293
11294   arg1 = (Dali::Matrix *)jarg1;
11295   {
11296     try {
11297       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11298     } catch (std::out_of_range& e) {
11299       {
11300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (std::exception& e) {
11303       {
11304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11305       };
11306     } catch (...) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11309       };
11310     }
11311   }
11312   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11318   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11319   Dali::Vector3 *arg2 = 0 ;
11320
11321   arg1 = (Dali::Matrix *)jarg1;
11322   arg2 = (Dali::Vector3 *)jarg2;
11323   if (!arg2) {
11324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11325     return ;
11326   }
11327   {
11328     try {
11329       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11337       };
11338     } catch (...) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11341       };
11342     }
11343   }
11344 }
11345
11346
11347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11348   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11349   Dali::Vector3 *arg2 = 0 ;
11350
11351   arg1 = (Dali::Matrix *)jarg1;
11352   arg2 = (Dali::Vector3 *)jarg2;
11353   if (!arg2) {
11354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11355     return ;
11356   }
11357   {
11358     try {
11359       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11367       };
11368     } catch (...) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11371       };
11372     }
11373   }
11374 }
11375
11376
11377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11378   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11379   Dali::Vector3 *arg2 = 0 ;
11380
11381   arg1 = (Dali::Matrix *)jarg1;
11382   arg2 = (Dali::Vector3 *)jarg2;
11383   if (!arg2) {
11384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11385     return ;
11386   }
11387   {
11388     try {
11389       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11390     } catch (std::out_of_range& e) {
11391       {
11392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11393       };
11394     } catch (std::exception& e) {
11395       {
11396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11397       };
11398     } catch (...) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11401       };
11402     }
11403   }
11404 }
11405
11406
11407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11408   void * jresult ;
11409   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11410   Dali::Vector4 *result = 0 ;
11411
11412   arg1 = (Dali::Matrix *)jarg1;
11413   {
11414     try {
11415       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11416     } catch (std::out_of_range& e) {
11417       {
11418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11419       };
11420     } catch (std::exception& e) {
11421       {
11422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11423       };
11424     } catch (...) {
11425       {
11426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11427       };
11428     }
11429   }
11430   jresult = (void *)result;
11431   return jresult;
11432 }
11433
11434
11435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11436   void * jresult ;
11437   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11438   Dali::Vector3 *result = 0 ;
11439
11440   arg1 = (Dali::Matrix *)jarg1;
11441   {
11442     try {
11443       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11444     } catch (std::out_of_range& e) {
11445       {
11446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (std::exception& e) {
11449       {
11450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11451       };
11452     } catch (...) {
11453       {
11454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11455       };
11456     }
11457   }
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11464   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11465   Dali::Vector4 *arg2 = 0 ;
11466
11467   arg1 = (Dali::Matrix *)jarg1;
11468   arg2 = (Dali::Vector4 *)jarg2;
11469   if (!arg2) {
11470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11471     return ;
11472   }
11473   {
11474     try {
11475       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11476     } catch (std::out_of_range& e) {
11477       {
11478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11479       };
11480     } catch (std::exception& e) {
11481       {
11482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11483       };
11484     } catch (...) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11487       };
11488     }
11489   }
11490 }
11491
11492
11493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11494   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11495   Dali::Vector3 *arg2 = 0 ;
11496
11497   arg1 = (Dali::Matrix *)jarg1;
11498   arg2 = (Dali::Vector3 *)jarg2;
11499   if (!arg2) {
11500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11501     return ;
11502   }
11503   {
11504     try {
11505       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11506     } catch (std::out_of_range& e) {
11507       {
11508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11509       };
11510     } catch (std::exception& e) {
11511       {
11512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11517       };
11518     }
11519   }
11520 }
11521
11522
11523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11524   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11525
11526   arg1 = (Dali::Matrix *)jarg1;
11527   {
11528     try {
11529       (arg1)->OrthoNormalize();
11530     } catch (std::out_of_range& e) {
11531       {
11532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11533       };
11534     } catch (std::exception& e) {
11535       {
11536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11537       };
11538     } catch (...) {
11539       {
11540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11541       };
11542     }
11543   }
11544 }
11545
11546
11547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11548   void * jresult ;
11549   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11550   float *result = 0 ;
11551
11552   arg1 = (Dali::Matrix *)jarg1;
11553   {
11554     try {
11555       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11563       };
11564     } catch (...) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11567       };
11568     }
11569   }
11570   jresult = (void *)result;
11571   return jresult;
11572 }
11573
11574
11575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11576   Dali::Matrix *arg1 = 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   Dali::Matrix *arg3 = 0 ;
11579
11580   arg1 = (Dali::Matrix *)jarg1;
11581   if (!arg1) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11583     return ;
11584   }
11585   arg2 = (Dali::Matrix *)jarg2;
11586   if (!arg2) {
11587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11588     return ;
11589   }
11590   arg3 = (Dali::Matrix *)jarg3;
11591   if (!arg3) {
11592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11593     return ;
11594   }
11595   {
11596     try {
11597       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11598     } catch (std::out_of_range& e) {
11599       {
11600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11601       };
11602     } catch (std::exception& e) {
11603       {
11604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11605       };
11606     } catch (...) {
11607       {
11608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11609       };
11610     }
11611   }
11612 }
11613
11614
11615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11616   Dali::Matrix *arg1 = 0 ;
11617   Dali::Matrix *arg2 = 0 ;
11618   Dali::Quaternion *arg3 = 0 ;
11619
11620   arg1 = (Dali::Matrix *)jarg1;
11621   if (!arg1) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11623     return ;
11624   }
11625   arg2 = (Dali::Matrix *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11628     return ;
11629   }
11630   arg3 = (Dali::Quaternion *)jarg3;
11631   if (!arg3) {
11632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11633     return ;
11634   }
11635   {
11636     try {
11637       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11638     } catch (std::out_of_range& e) {
11639       {
11640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11641       };
11642     } catch (std::exception& e) {
11643       {
11644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11645       };
11646     } catch (...) {
11647       {
11648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11649       };
11650     }
11651   }
11652 }
11653
11654
11655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11656   void * jresult ;
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector4 *arg2 = 0 ;
11659   Dali::Vector4 result;
11660
11661   arg1 = (Dali::Matrix *)jarg1;
11662   arg2 = (Dali::Vector4 *)jarg2;
11663   if (!arg2) {
11664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11665     return 0;
11666   }
11667   {
11668     try {
11669       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11670     } catch (std::out_of_range& e) {
11671       {
11672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (std::exception& e) {
11675       {
11676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11677       };
11678     } catch (...) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11681       };
11682     }
11683   }
11684   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11685   return jresult;
11686 }
11687
11688
11689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11690   unsigned int jresult ;
11691   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11692   Dali::Matrix *arg2 = 0 ;
11693   bool result;
11694
11695   arg1 = (Dali::Matrix *)jarg1;
11696   arg2 = (Dali::Matrix *)jarg2;
11697   if (!arg2) {
11698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11699     return 0;
11700   }
11701   {
11702     try {
11703       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11704     } catch (std::out_of_range& e) {
11705       {
11706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11707       };
11708     } catch (std::exception& e) {
11709       {
11710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11711       };
11712     } catch (...) {
11713       {
11714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11715       };
11716     }
11717   }
11718   jresult = result;
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11724   unsigned int jresult ;
11725   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11726   Dali::Matrix *arg2 = 0 ;
11727   bool result;
11728
11729   arg1 = (Dali::Matrix *)jarg1;
11730   arg2 = (Dali::Matrix *)jarg2;
11731   if (!arg2) {
11732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11733     return 0;
11734   }
11735   {
11736     try {
11737       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11745       };
11746     } catch (...) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11749       };
11750     }
11751   }
11752   jresult = result;
11753   return jresult;
11754 }
11755
11756
11757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11759   Dali::Vector3 *arg2 = 0 ;
11760   Dali::Quaternion *arg3 = 0 ;
11761   Dali::Vector3 *arg4 = 0 ;
11762
11763   arg1 = (Dali::Matrix *)jarg1;
11764   arg2 = (Dali::Vector3 *)jarg2;
11765   if (!arg2) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11767     return ;
11768   }
11769   arg3 = (Dali::Quaternion *)jarg3;
11770   if (!arg3) {
11771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11772     return ;
11773   }
11774   arg4 = (Dali::Vector3 *)jarg4;
11775   if (!arg4) {
11776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11777     return ;
11778   }
11779   {
11780     try {
11781       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11782     } catch (std::out_of_range& e) {
11783       {
11784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11785       };
11786     } catch (std::exception& e) {
11787       {
11788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (...) {
11791       {
11792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11793       };
11794     }
11795   }
11796 }
11797
11798
11799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11800   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11801   Dali::Vector3 *arg2 = 0 ;
11802   Dali::Quaternion *arg3 = 0 ;
11803   Dali::Vector3 *arg4 = 0 ;
11804
11805   arg1 = (Dali::Matrix *)jarg1;
11806   arg2 = (Dali::Vector3 *)jarg2;
11807   if (!arg2) {
11808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11809     return ;
11810   }
11811   arg3 = (Dali::Quaternion *)jarg3;
11812   if (!arg3) {
11813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11814     return ;
11815   }
11816   arg4 = (Dali::Vector3 *)jarg4;
11817   if (!arg4) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11819     return ;
11820   }
11821   {
11822     try {
11823       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11824     } catch (std::out_of_range& e) {
11825       {
11826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11827       };
11828     } catch (std::exception& e) {
11829       {
11830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11831       };
11832     } catch (...) {
11833       {
11834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11835       };
11836     }
11837   }
11838 }
11839
11840
11841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11842   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11843   Dali::Vector3 *arg2 = 0 ;
11844   Dali::Vector3 *arg3 = 0 ;
11845   Dali::Vector3 *arg4 = 0 ;
11846   Dali::Vector3 *arg5 = 0 ;
11847
11848   arg1 = (Dali::Matrix *)jarg1;
11849   arg2 = (Dali::Vector3 *)jarg2;
11850   if (!arg2) {
11851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11852     return ;
11853   }
11854   arg3 = (Dali::Vector3 *)jarg3;
11855   if (!arg3) {
11856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11857     return ;
11858   }
11859   arg4 = (Dali::Vector3 *)jarg4;
11860   if (!arg4) {
11861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11862     return ;
11863   }
11864   arg5 = (Dali::Vector3 *)jarg5;
11865   if (!arg5) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11867     return ;
11868   }
11869   {
11870     try {
11871       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11879       };
11880     } catch (...) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11883       };
11884     }
11885   }
11886 }
11887
11888
11889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11890   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11891   Dali::Vector3 *arg2 = 0 ;
11892   Dali::Quaternion *arg3 = 0 ;
11893   Dali::Vector3 *arg4 = 0 ;
11894
11895   arg1 = (Dali::Matrix *)jarg1;
11896   arg2 = (Dali::Vector3 *)jarg2;
11897   if (!arg2) {
11898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11899     return ;
11900   }
11901   arg3 = (Dali::Quaternion *)jarg3;
11902   if (!arg3) {
11903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11904     return ;
11905   }
11906   arg4 = (Dali::Vector3 *)jarg4;
11907   if (!arg4) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11909     return ;
11910   }
11911   {
11912     try {
11913       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11914     } catch (std::out_of_range& e) {
11915       {
11916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11917       };
11918     } catch (std::exception& e) {
11919       {
11920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11925       };
11926     }
11927   }
11928 }
11929
11930
11931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11932   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11933
11934   arg1 = (Dali::Matrix *)jarg1;
11935   {
11936     try {
11937       delete arg1;
11938     } catch (std::out_of_range& e) {
11939       {
11940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11941       };
11942     } catch (std::exception& e) {
11943       {
11944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11945       };
11946     } catch (...) {
11947       {
11948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11949       };
11950     }
11951   }
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11956   void * jresult ;
11957   Dali::Matrix3 *result = 0 ;
11958
11959   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11960   jresult = (void *)result;
11961   return jresult;
11962 }
11963
11964
11965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11966   void * jresult ;
11967   Dali::Matrix3 *result = 0 ;
11968
11969   {
11970     try {
11971       result = (Dali::Matrix3 *)new Dali::Matrix3();
11972     } catch (std::out_of_range& e) {
11973       {
11974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (std::exception& e) {
11977       {
11978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986   jresult = (void *)result;
11987   return jresult;
11988 }
11989
11990
11991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11992   void * jresult ;
11993   Dali::Matrix3 *arg1 = 0 ;
11994   Dali::Matrix3 *result = 0 ;
11995
11996   arg1 = (Dali::Matrix3 *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11999     return 0;
12000   }
12001   {
12002     try {
12003       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12004     } catch (std::out_of_range& e) {
12005       {
12006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12007       };
12008     } catch (std::exception& e) {
12009       {
12010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (...) {
12013       {
12014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12015       };
12016     }
12017   }
12018   jresult = (void *)result;
12019   return jresult;
12020 }
12021
12022
12023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12024   void * jresult ;
12025   Dali::Matrix *arg1 = 0 ;
12026   Dali::Matrix3 *result = 0 ;
12027
12028   arg1 = (Dali::Matrix *)jarg1;
12029   if (!arg1) {
12030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12031     return 0;
12032   }
12033   {
12034     try {
12035       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12036     } catch (std::out_of_range& e) {
12037       {
12038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12039       };
12040     } catch (std::exception& e) {
12041       {
12042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12043       };
12044     } catch (...) {
12045       {
12046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12047       };
12048     }
12049   }
12050   jresult = (void *)result;
12051   return jresult;
12052 }
12053
12054
12055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
12056   void * jresult ;
12057   float arg1 ;
12058   float arg2 ;
12059   float arg3 ;
12060   float arg4 ;
12061   float arg5 ;
12062   float arg6 ;
12063   float arg7 ;
12064   float arg8 ;
12065   float arg9 ;
12066   Dali::Matrix3 *result = 0 ;
12067
12068   arg1 = (float)jarg1;
12069   arg2 = (float)jarg2;
12070   arg3 = (float)jarg3;
12071   arg4 = (float)jarg4;
12072   arg5 = (float)jarg5;
12073   arg6 = (float)jarg6;
12074   arg7 = (float)jarg7;
12075   arg8 = (float)jarg8;
12076   arg9 = (float)jarg9;
12077   {
12078     try {
12079       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12080     } catch (std::out_of_range& e) {
12081       {
12082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (std::exception& e) {
12085       {
12086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12087       };
12088     } catch (...) {
12089       {
12090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12091       };
12092     }
12093   }
12094   jresult = (void *)result;
12095   return jresult;
12096 }
12097
12098
12099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12100   void * jresult ;
12101   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12102   Dali::Matrix3 *arg2 = 0 ;
12103   Dali::Matrix3 *result = 0 ;
12104
12105   arg1 = (Dali::Matrix3 *)jarg1;
12106   arg2 = (Dali::Matrix3 *)jarg2;
12107   if (!arg2) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12109     return 0;
12110   }
12111   {
12112     try {
12113       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128   jresult = (void *)result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12134   void * jresult ;
12135   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12136   Dali::Matrix *arg2 = 0 ;
12137   Dali::Matrix3 *result = 0 ;
12138
12139   arg1 = (Dali::Matrix3 *)jarg1;
12140   arg2 = (Dali::Matrix *)jarg2;
12141   if (!arg2) {
12142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12143     return 0;
12144   }
12145   {
12146     try {
12147       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12148     } catch (std::out_of_range& e) {
12149       {
12150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12151       };
12152     } catch (std::exception& e) {
12153       {
12154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (...) {
12157       {
12158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12159       };
12160     }
12161   }
12162   jresult = (void *)result;
12163   return jresult;
12164 }
12165
12166
12167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12168   unsigned int jresult ;
12169   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12170   Dali::Matrix3 *arg2 = 0 ;
12171   bool result;
12172
12173   arg1 = (Dali::Matrix3 *)jarg1;
12174   arg2 = (Dali::Matrix3 *)jarg2;
12175   if (!arg2) {
12176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12177     return 0;
12178   }
12179   {
12180     try {
12181       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12182     } catch (std::out_of_range& e) {
12183       {
12184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12185       };
12186     } catch (std::exception& e) {
12187       {
12188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (...) {
12191       {
12192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12193       };
12194     }
12195   }
12196   jresult = result;
12197   return jresult;
12198 }
12199
12200
12201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12202   unsigned int jresult ;
12203   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12204   Dali::Matrix3 *arg2 = 0 ;
12205   bool result;
12206
12207   arg1 = (Dali::Matrix3 *)jarg1;
12208   arg2 = (Dali::Matrix3 *)jarg2;
12209   if (!arg2) {
12210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12211     return 0;
12212   }
12213   {
12214     try {
12215       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12216     } catch (std::out_of_range& e) {
12217       {
12218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12219       };
12220     } catch (std::exception& e) {
12221       {
12222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (...) {
12225       {
12226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12227       };
12228     }
12229   }
12230   jresult = result;
12231   return jresult;
12232 }
12233
12234
12235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12236   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12237
12238   arg1 = (Dali::Matrix3 *)jarg1;
12239   {
12240     try {
12241       delete arg1;
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (...) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12253       };
12254     }
12255   }
12256 }
12257
12258
12259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12260   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12261
12262   arg1 = (Dali::Matrix3 *)jarg1;
12263   {
12264     try {
12265       (arg1)->SetIdentity();
12266     } catch (std::out_of_range& e) {
12267       {
12268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12269       };
12270     } catch (std::exception& e) {
12271       {
12272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12273       };
12274     } catch (...) {
12275       {
12276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12277       };
12278     }
12279   }
12280 }
12281
12282
12283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12284   void * jresult ;
12285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12286   float *result = 0 ;
12287
12288   arg1 = (Dali::Matrix3 *)jarg1;
12289   {
12290     try {
12291       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12303       };
12304     }
12305   }
12306   jresult = (void *)result;
12307   return jresult;
12308 }
12309
12310
12311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12312   unsigned int jresult ;
12313   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12314   bool result;
12315
12316   arg1 = (Dali::Matrix3 *)jarg1;
12317   {
12318     try {
12319       result = (bool)(arg1)->Invert();
12320     } catch (std::out_of_range& e) {
12321       {
12322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12323       };
12324     } catch (std::exception& e) {
12325       {
12326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (...) {
12329       {
12330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12331       };
12332     }
12333   }
12334   jresult = result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12340   unsigned int jresult ;
12341   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12342   bool result;
12343
12344   arg1 = (Dali::Matrix3 *)jarg1;
12345   {
12346     try {
12347       result = (bool)(arg1)->Transpose();
12348     } catch (std::out_of_range& e) {
12349       {
12350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12351       };
12352     } catch (std::exception& e) {
12353       {
12354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12355       };
12356     } catch (...) {
12357       {
12358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12359       };
12360     }
12361   }
12362   jresult = result;
12363   return jresult;
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12368   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12369   float arg2 ;
12370
12371   arg1 = (Dali::Matrix3 *)jarg1;
12372   arg2 = (float)jarg2;
12373   {
12374     try {
12375       (arg1)->Scale(arg2);
12376     } catch (std::out_of_range& e) {
12377       {
12378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12379       };
12380     } catch (std::exception& e) {
12381       {
12382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12383       };
12384     } catch (...) {
12385       {
12386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12387       };
12388     }
12389   }
12390 }
12391
12392
12393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12394   float jresult ;
12395   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12396   float result;
12397
12398   arg1 = (Dali::Matrix3 *)jarg1;
12399   {
12400     try {
12401       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12402     } catch (std::out_of_range& e) {
12403       {
12404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12405       };
12406     } catch (std::exception& e) {
12407       {
12408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12413       };
12414     }
12415   }
12416   jresult = result;
12417   return jresult;
12418 }
12419
12420
12421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12422   unsigned int jresult ;
12423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12424   bool result;
12425
12426   arg1 = (Dali::Matrix3 *)jarg1;
12427   {
12428     try {
12429       result = (bool)(arg1)->ScaledInverseTranspose();
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12437       };
12438     } catch (...) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12441       };
12442     }
12443   }
12444   jresult = result;
12445   return jresult;
12446 }
12447
12448
12449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12450   Dali::Matrix3 *arg1 = 0 ;
12451   Dali::Matrix3 *arg2 = 0 ;
12452   Dali::Matrix3 *arg3 = 0 ;
12453
12454   arg1 = (Dali::Matrix3 *)jarg1;
12455   if (!arg1) {
12456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12457     return ;
12458   }
12459   arg2 = (Dali::Matrix3 *)jarg2;
12460   if (!arg2) {
12461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12462     return ;
12463   }
12464   arg3 = (Dali::Matrix3 *)jarg3;
12465   if (!arg3) {
12466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12467     return ;
12468   }
12469   {
12470     try {
12471       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12472     } catch (std::out_of_range& e) {
12473       {
12474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12475       };
12476     } catch (std::exception& e) {
12477       {
12478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12483       };
12484     }
12485   }
12486 }
12487
12488
12489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12490   float jresult ;
12491   float arg1 ;
12492   float arg2 ;
12493   float result;
12494
12495   arg1 = (float)jarg1;
12496   arg2 = (float)jarg2;
12497   {
12498     try {
12499       result = (float)Dali::Random::Range(arg1,arg2);
12500     } catch (std::out_of_range& e) {
12501       {
12502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (std::exception& e) {
12505       {
12506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12511       };
12512     }
12513   }
12514   jresult = result;
12515   return jresult;
12516 }
12517
12518
12519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12520   void * jresult ;
12521   Dali::Vector4 result;
12522
12523   {
12524     try {
12525       result = Dali::Random::Axis();
12526     } catch (std::out_of_range& e) {
12527       {
12528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12529       };
12530     } catch (std::exception& e) {
12531       {
12532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12533       };
12534     } catch (...) {
12535       {
12536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12537       };
12538     }
12539   }
12540   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12541   return jresult;
12542 }
12543
12544
12545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12546   void * jresult ;
12547   Dali::AngleAxis *result = 0 ;
12548
12549   {
12550     try {
12551       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12552     } catch (std::out_of_range& e) {
12553       {
12554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12555       };
12556     } catch (std::exception& e) {
12557       {
12558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12563       };
12564     }
12565   }
12566   jresult = (void *)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12572   void * jresult ;
12573   Dali::Radian arg1 ;
12574   Dali::Vector3 *arg2 = 0 ;
12575   Dali::Radian *argp1 ;
12576   Dali::AngleAxis *result = 0 ;
12577
12578   argp1 = (Dali::Radian *)jarg1;
12579   if (!argp1) {
12580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12581     return 0;
12582   }
12583   arg1 = *argp1;
12584   arg2 = (Dali::Vector3 *)jarg2;
12585   if (!arg2) {
12586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12587     return 0;
12588   }
12589   {
12590     try {
12591       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12592     } catch (std::out_of_range& e) {
12593       {
12594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12595       };
12596     } catch (std::exception& e) {
12597       {
12598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12599       };
12600     } catch (...) {
12601       {
12602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12603       };
12604     }
12605   }
12606   jresult = (void *)result;
12607   return jresult;
12608 }
12609
12610
12611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12612   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12613   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12614
12615   arg1 = (Dali::AngleAxis *)jarg1;
12616   arg2 = (Dali::Radian *)jarg2;
12617   if (arg1) (arg1)->angle = *arg2;
12618 }
12619
12620
12621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12622   void * jresult ;
12623   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12624   Dali::Radian *result = 0 ;
12625
12626   arg1 = (Dali::AngleAxis *)jarg1;
12627   result = (Dali::Radian *)& ((arg1)->angle);
12628   jresult = (void *)result;
12629   return jresult;
12630 }
12631
12632
12633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12634   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12635   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12636
12637   arg1 = (Dali::AngleAxis *)jarg1;
12638   arg2 = (Dali::Vector3 *)jarg2;
12639   if (arg1) (arg1)->axis = *arg2;
12640 }
12641
12642
12643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12644   void * jresult ;
12645   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12646   Dali::Vector3 *result = 0 ;
12647
12648   arg1 = (Dali::AngleAxis *)jarg1;
12649   result = (Dali::Vector3 *)& ((arg1)->axis);
12650   jresult = (void *)result;
12651   return jresult;
12652 }
12653
12654
12655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12656   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12657
12658   arg1 = (Dali::AngleAxis *)jarg1;
12659   {
12660     try {
12661       delete arg1;
12662     } catch (std::out_of_range& e) {
12663       {
12664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12665       };
12666     } catch (std::exception& e) {
12667       {
12668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12669       };
12670     } catch (...) {
12671       {
12672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12673       };
12674     }
12675   }
12676 }
12677
12678
12679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12680   unsigned int jresult ;
12681   Dali::AngleAxis *arg1 = 0 ;
12682   Dali::AngleAxis *arg2 = 0 ;
12683   bool result;
12684
12685   arg1 = (Dali::AngleAxis *)jarg1;
12686   if (!arg1) {
12687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12688     return 0;
12689   }
12690   arg2 = (Dali::AngleAxis *)jarg2;
12691   if (!arg2) {
12692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12693     return 0;
12694   }
12695   {
12696     try {
12697       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12698     } catch (std::out_of_range& e) {
12699       {
12700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12701       };
12702     } catch (std::exception& e) {
12703       {
12704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12705       };
12706     } catch (...) {
12707       {
12708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12709       };
12710     }
12711   }
12712   jresult = result;
12713   return jresult;
12714 }
12715
12716
12717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12718   unsigned int jresult ;
12719   unsigned int arg1 ;
12720   unsigned int result;
12721
12722   arg1 = (unsigned int)jarg1;
12723   {
12724     try {
12725       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12726     } catch (std::out_of_range& e) {
12727       {
12728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12729       };
12730     } catch (std::exception& e) {
12731       {
12732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (...) {
12735       {
12736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12737       };
12738     }
12739   }
12740   jresult = result;
12741   return jresult;
12742 }
12743
12744
12745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12746   unsigned int jresult ;
12747   unsigned int arg1 ;
12748   bool result;
12749
12750   arg1 = (unsigned int)jarg1;
12751   {
12752     try {
12753       result = (bool)Dali::IsPowerOfTwo(arg1);
12754     } catch (std::out_of_range& e) {
12755       {
12756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12757       };
12758     } catch (std::exception& e) {
12759       {
12760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12761       };
12762     } catch (...) {
12763       {
12764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12765       };
12766     }
12767   }
12768   jresult = result;
12769   return jresult;
12770 }
12771
12772
12773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12774   float jresult ;
12775   float arg1 ;
12776   float arg2 ;
12777   float result;
12778
12779   arg1 = (float)jarg1;
12780   arg2 = (float)jarg2;
12781   {
12782     try {
12783       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12784     } catch (std::out_of_range& e) {
12785       {
12786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12787       };
12788     } catch (std::exception& e) {
12789       {
12790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12791       };
12792     } catch (...) {
12793       {
12794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12795       };
12796     }
12797   }
12798   jresult = result;
12799   return jresult;
12800 }
12801
12802
12803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12804   unsigned int jresult ;
12805   float arg1 ;
12806   bool result;
12807
12808   arg1 = (float)jarg1;
12809   {
12810     try {
12811       result = (bool)Dali::EqualsZero(arg1);
12812     } catch (std::out_of_range& e) {
12813       {
12814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (std::exception& e) {
12817       {
12818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826   jresult = result;
12827   return jresult;
12828 }
12829
12830
12831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12832   unsigned int jresult ;
12833   float arg1 ;
12834   float arg2 ;
12835   bool result;
12836
12837   arg1 = (float)jarg1;
12838   arg2 = (float)jarg2;
12839   {
12840     try {
12841       result = (bool)Dali::Equals(arg1,arg2);
12842     } catch (std::out_of_range& e) {
12843       {
12844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12845       };
12846     } catch (std::exception& e) {
12847       {
12848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12849       };
12850     } catch (...) {
12851       {
12852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12853       };
12854     }
12855   }
12856   jresult = result;
12857   return jresult;
12858 }
12859
12860
12861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12862   unsigned int jresult ;
12863   float arg1 ;
12864   float arg2 ;
12865   float arg3 ;
12866   bool result;
12867
12868   arg1 = (float)jarg1;
12869   arg2 = (float)jarg2;
12870   arg3 = (float)jarg3;
12871   {
12872     try {
12873       result = (bool)Dali::Equals(arg1,arg2,arg3);
12874     } catch (std::out_of_range& e) {
12875       {
12876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12877       };
12878     } catch (std::exception& e) {
12879       {
12880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12881       };
12882     } catch (...) {
12883       {
12884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12885       };
12886     }
12887   }
12888   jresult = result;
12889   return jresult;
12890 }
12891
12892
12893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12894   float jresult ;
12895   float arg1 ;
12896   int arg2 ;
12897   float result;
12898
12899   arg1 = (float)jarg1;
12900   arg2 = (int)jarg2;
12901   {
12902     try {
12903       result = (float)Dali::Round(arg1,arg2);
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12911       };
12912     } catch (...) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12915       };
12916     }
12917   }
12918   jresult = result;
12919   return jresult;
12920 }
12921
12922
12923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12924   float jresult ;
12925   float arg1 ;
12926   float arg2 ;
12927   float arg3 ;
12928   float result;
12929
12930   arg1 = (float)jarg1;
12931   arg2 = (float)jarg2;
12932   arg3 = (float)jarg3;
12933   {
12934     try {
12935       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12936     } catch (std::out_of_range& e) {
12937       {
12938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (std::exception& e) {
12941       {
12942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (...) {
12945       {
12946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12947       };
12948     }
12949   }
12950   jresult = result;
12951   return jresult;
12952 }
12953
12954
12955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12956   float jresult ;
12957   float arg1 ;
12958   float arg2 ;
12959   float arg3 ;
12960   float arg4 ;
12961   float result;
12962
12963   arg1 = (float)jarg1;
12964   arg2 = (float)jarg2;
12965   arg3 = (float)jarg3;
12966   arg4 = (float)jarg4;
12967   {
12968     try {
12969       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12970     } catch (std::out_of_range& e) {
12971       {
12972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12973       };
12974     } catch (std::exception& e) {
12975       {
12976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12977       };
12978     } catch (...) {
12979       {
12980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12981       };
12982     }
12983   }
12984   jresult = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12990   int jresult ;
12991   int result;
12992
12993   result = (int)(int)Dali::Property::INVALID_INDEX;
12994   jresult = result;
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
13000   int jresult ;
13001   int result;
13002
13003   result = (int)(int)Dali::Property::INVALID_KEY;
13004   jresult = result;
13005   return jresult;
13006 }
13007
13008
13009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13010   int jresult ;
13011   int result;
13012
13013   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13014   jresult = result;
13015   return jresult;
13016 }
13017
13018
13019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13020   void * jresult ;
13021   Dali::Handle *arg1 = 0 ;
13022   Dali::Property::Index arg2 ;
13023   Dali::Property *result = 0 ;
13024
13025   arg1 = (Dali::Handle *)jarg1;
13026   if (!arg1) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13028     return 0;
13029   }
13030   arg2 = (Dali::Property::Index)jarg2;
13031   {
13032     try {
13033       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13034     } catch (std::out_of_range& e) {
13035       {
13036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13037       };
13038     } catch (std::exception& e) {
13039       {
13040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13041       };
13042     } catch (...) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13045       };
13046     }
13047   }
13048   jresult = (void *)result;
13049   return jresult;
13050 }
13051
13052
13053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13054   void * jresult ;
13055   Dali::Handle *arg1 = 0 ;
13056   Dali::Property::Index arg2 ;
13057   int arg3 ;
13058   Dali::Property *result = 0 ;
13059
13060   arg1 = (Dali::Handle *)jarg1;
13061   if (!arg1) {
13062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13063     return 0;
13064   }
13065   arg2 = (Dali::Property::Index)jarg2;
13066   arg3 = (int)jarg3;
13067   {
13068     try {
13069       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084   jresult = (void *)result;
13085   return jresult;
13086 }
13087
13088
13089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13090   void * jresult ;
13091   Dali::Handle *arg1 = 0 ;
13092   std::string *arg2 = 0 ;
13093   Dali::Property *result = 0 ;
13094
13095   arg1 = (Dali::Handle *)jarg1;
13096   if (!arg1) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13098     return 0;
13099   }
13100   if (!jarg2) {
13101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13102     return 0;
13103   }
13104   std::string arg2_str(jarg2);
13105   arg2 = &arg2_str;
13106   {
13107     try {
13108       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (...) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13120       };
13121     }
13122   }
13123   jresult = (void *)result;
13124
13125   //argout typemap for const std::string&
13126
13127   return jresult;
13128 }
13129
13130
13131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13132   void * jresult ;
13133   Dali::Handle *arg1 = 0 ;
13134   std::string *arg2 = 0 ;
13135   int arg3 ;
13136   Dali::Property *result = 0 ;
13137
13138   arg1 = (Dali::Handle *)jarg1;
13139   if (!arg1) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13141     return 0;
13142   }
13143   if (!jarg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13145     return 0;
13146   }
13147   std::string arg2_str(jarg2);
13148   arg2 = &arg2_str;
13149   arg3 = (int)jarg3;
13150   {
13151     try {
13152       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13153     } catch (std::out_of_range& e) {
13154       {
13155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13156       };
13157     } catch (std::exception& e) {
13158       {
13159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13164       };
13165     }
13166   }
13167   jresult = (void *)result;
13168
13169   //argout typemap for const std::string&
13170
13171   return jresult;
13172 }
13173
13174
13175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177
13178   arg1 = (Dali::Property *)jarg1;
13179   {
13180     try {
13181       delete arg1;
13182     } catch (std::out_of_range& e) {
13183       {
13184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13185       };
13186     } catch (std::exception& e) {
13187       {
13188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13189       };
13190     } catch (...) {
13191       {
13192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13193       };
13194     }
13195   }
13196 }
13197
13198
13199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13200   Dali::Property *arg1 = (Dali::Property *) 0 ;
13201   Dali::Handle *arg2 = 0 ;
13202
13203   arg1 = (Dali::Property *)jarg1;
13204   arg2 = (Dali::Handle *)jarg2;
13205   if (!arg2) {
13206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13207     return ;
13208   }
13209   if (arg1) (arg1)->object = *arg2;
13210 }
13211
13212
13213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13214   void * jresult ;
13215   Dali::Property *arg1 = (Dali::Property *) 0 ;
13216   Dali::Handle *result = 0 ;
13217
13218   arg1 = (Dali::Property *)jarg1;
13219   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13220   jresult = (void *)result;
13221   return jresult;
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13226   Dali::Property *arg1 = (Dali::Property *) 0 ;
13227   Dali::Property::Index arg2 ;
13228
13229   arg1 = (Dali::Property *)jarg1;
13230   arg2 = (Dali::Property::Index)jarg2;
13231   if (arg1) (arg1)->propertyIndex = arg2;
13232 }
13233
13234
13235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13236   int jresult ;
13237   Dali::Property *arg1 = (Dali::Property *) 0 ;
13238   Dali::Property::Index result;
13239
13240   arg1 = (Dali::Property *)jarg1;
13241   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13242   jresult = result;
13243   return jresult;
13244 }
13245
13246
13247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13248   Dali::Property *arg1 = (Dali::Property *) 0 ;
13249   int arg2 ;
13250
13251   arg1 = (Dali::Property *)jarg1;
13252   arg2 = (int)jarg2;
13253   if (arg1) (arg1)->componentIndex = arg2;
13254 }
13255
13256
13257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13258   int jresult ;
13259   Dali::Property *arg1 = (Dali::Property *) 0 ;
13260   int result;
13261
13262   arg1 = (Dali::Property *)jarg1;
13263   result = (int) ((arg1)->componentIndex);
13264   jresult = result;
13265   return jresult;
13266 }
13267
13268
13269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13270   void * jresult ;
13271   Dali::Property::Array *result = 0 ;
13272
13273   {
13274     try {
13275       result = (Dali::Property::Array *)new Dali::Property::Array();
13276     } catch (std::out_of_range& e) {
13277       {
13278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13279       };
13280     } catch (std::exception& e) {
13281       {
13282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13283       };
13284     } catch (...) {
13285       {
13286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13287       };
13288     }
13289   }
13290   jresult = (void *)result;
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13296   void * jresult ;
13297   Dali::Property::Array *arg1 = 0 ;
13298   Dali::Property::Array *result = 0 ;
13299
13300   arg1 = (Dali::Property::Array *)jarg1;
13301   if (!arg1) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13303     return 0;
13304   }
13305   {
13306     try {
13307       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13308     } catch (std::out_of_range& e) {
13309       {
13310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13311       };
13312     } catch (std::exception& e) {
13313       {
13314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13315       };
13316     } catch (...) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13319       };
13320     }
13321   }
13322   jresult = (void *)result;
13323   return jresult;
13324 }
13325
13326
13327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13328   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13329
13330   arg1 = (Dali::Property::Array *)jarg1;
13331   {
13332     try {
13333       delete arg1;
13334     } catch (std::out_of_range& e) {
13335       {
13336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13337       };
13338     } catch (std::exception& e) {
13339       {
13340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13345       };
13346     }
13347   }
13348 }
13349
13350
13351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13352   unsigned long jresult ;
13353   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13354   Dali::Property::Array::SizeType result;
13355
13356   arg1 = (Dali::Property::Array *)jarg1;
13357   {
13358     try {
13359       result = ((Dali::Property::Array const *)arg1)->Size();
13360     } catch (std::out_of_range& e) {
13361       {
13362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13363       };
13364     } catch (std::exception& e) {
13365       {
13366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13367       };
13368     } catch (...) {
13369       {
13370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13371       };
13372     }
13373   }
13374   jresult = (unsigned long)result;
13375   return jresult;
13376 }
13377
13378
13379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13380   unsigned long jresult ;
13381   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13382   Dali::Property::Array::SizeType result;
13383
13384   arg1 = (Dali::Property::Array *)jarg1;
13385   {
13386     try {
13387       result = ((Dali::Property::Array const *)arg1)->Count();
13388     } catch (std::out_of_range& e) {
13389       {
13390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13391       };
13392     } catch (std::exception& e) {
13393       {
13394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13395       };
13396     } catch (...) {
13397       {
13398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13399       };
13400     }
13401   }
13402   jresult = (unsigned long)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13408   unsigned int jresult ;
13409   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13410   bool result;
13411
13412   arg1 = (Dali::Property::Array *)jarg1;
13413   {
13414     try {
13415       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13416     } catch (std::out_of_range& e) {
13417       {
13418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (std::exception& e) {
13421       {
13422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430   jresult = result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13436   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13437
13438   arg1 = (Dali::Property::Array *)jarg1;
13439   {
13440     try {
13441       (arg1)->Clear();
13442     } catch (std::out_of_range& e) {
13443       {
13444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13445       };
13446     } catch (std::exception& e) {
13447       {
13448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13453       };
13454     }
13455   }
13456 }
13457
13458
13459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13460   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13461   Dali::Property::Array::SizeType arg2 ;
13462
13463   arg1 = (Dali::Property::Array *)jarg1;
13464   arg2 = (Dali::Property::Array::SizeType)jarg2;
13465   {
13466     try {
13467       (arg1)->Reserve(arg2);
13468     } catch (std::out_of_range& e) {
13469       {
13470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13471       };
13472     } catch (std::exception& e) {
13473       {
13474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13475       };
13476     } catch (...) {
13477       {
13478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13479       };
13480     }
13481   }
13482 }
13483
13484
13485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13486   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13487   Dali::Property::Array::SizeType arg2 ;
13488
13489   arg1 = (Dali::Property::Array *)jarg1;
13490   arg2 = (Dali::Property::Array::SizeType)jarg2;
13491   {
13492     try {
13493       (arg1)->Resize(arg2);
13494     } catch (std::out_of_range& e) {
13495       {
13496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13497       };
13498     } catch (std::exception& e) {
13499       {
13500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13501       };
13502     } catch (...) {
13503       {
13504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13505       };
13506     }
13507   }
13508 }
13509
13510
13511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13512   unsigned long jresult ;
13513   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13514   Dali::Property::Array::SizeType result;
13515
13516   arg1 = (Dali::Property::Array *)jarg1;
13517   {
13518     try {
13519       result = (arg1)->Capacity();
13520     } catch (std::out_of_range& e) {
13521       {
13522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13523       };
13524     } catch (std::exception& e) {
13525       {
13526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13527       };
13528     } catch (...) {
13529       {
13530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13531       };
13532     }
13533   }
13534   jresult = (unsigned long)result;
13535   return jresult;
13536 }
13537
13538
13539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13540   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13541   Dali::Property::Value *arg2 = 0 ;
13542
13543   arg1 = (Dali::Property::Array *)jarg1;
13544   arg2 = (Dali::Property::Value *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13547     return ;
13548   }
13549   {
13550     try {
13551       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13552     } catch (std::out_of_range& e) {
13553       {
13554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13555       };
13556     } catch (std::exception& e) {
13557       {
13558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13559       };
13560     } catch (...) {
13561       {
13562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13563       };
13564     }
13565   }
13566 }
13567
13568
13569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13570   void * jresult ;
13571   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13572   Dali::Property::Value *arg2 = 0 ;
13573   Dali::Property::Array *result = 0 ;
13574
13575   arg1 = (Dali::Property::Array *)jarg1;
13576   arg2 = (Dali::Property::Value *)jarg2;
13577   if (!arg2) {
13578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13579     return 0;
13580   }
13581   {
13582     try {
13583       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13584     } catch (std::out_of_range& e) {
13585       {
13586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13587       };
13588     } catch (std::exception& e) {
13589       {
13590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13591       };
13592     } catch (...) {
13593       {
13594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13595       };
13596     }
13597   }
13598   jresult = (void *)result;
13599   return jresult;
13600 }
13601
13602
13603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13604   void * jresult ;
13605   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13606   Dali::Property::Array::SizeType arg2 ;
13607   Dali::Property::Value *result = 0 ;
13608
13609   arg1 = (Dali::Property::Array *)jarg1;
13610   arg2 = (Dali::Property::Array::SizeType)jarg2;
13611   {
13612     try {
13613       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13614     } catch (std::out_of_range& e) {
13615       {
13616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (std::exception& e) {
13619       {
13620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13634   void * jresult ;
13635   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13636   Dali::Property::Array::SizeType arg2 ;
13637   Dali::Property::Value *result = 0 ;
13638
13639   arg1 = (Dali::Property::Array *)jarg1;
13640   arg2 = (Dali::Property::Array::SizeType)jarg2;
13641   {
13642     try {
13643       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (...) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13655       };
13656     }
13657   }
13658   jresult = (void *)result;
13659   return jresult;
13660 }
13661
13662
13663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13664   void * jresult ;
13665   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13666   Dali::Property::Array *arg2 = 0 ;
13667   Dali::Property::Array *result = 0 ;
13668
13669   arg1 = (Dali::Property::Array *)jarg1;
13670   arg2 = (Dali::Property::Array *)jarg2;
13671   if (!arg2) {
13672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13673     return 0;
13674   }
13675   {
13676     try {
13677       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13678     } catch (std::out_of_range& e) {
13679       {
13680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13681       };
13682     } catch (std::exception& e) {
13683       {
13684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13685       };
13686     } catch (...) {
13687       {
13688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13689       };
13690     }
13691   }
13692   jresult = (void *)result;
13693   return jresult;
13694 }
13695
13696
13697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13698   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13699   enum Dali::Property::Key::Type arg2 ;
13700
13701   arg1 = (Dali::Property::Key *)jarg1;
13702   arg2 = (enum Dali::Property::Key::Type)jarg2;
13703   if (arg1) (arg1)->type = arg2;
13704 }
13705
13706
13707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13708   int jresult ;
13709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13710   enum Dali::Property::Key::Type result;
13711
13712   arg1 = (Dali::Property::Key *)jarg1;
13713   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13714   jresult = (int)result;
13715   return jresult;
13716 }
13717
13718
13719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13720   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13721   Dali::Property::Index arg2 ;
13722
13723   arg1 = (Dali::Property::Key *)jarg1;
13724   arg2 = (Dali::Property::Index)jarg2;
13725   if (arg1) (arg1)->indexKey = arg2;
13726 }
13727
13728
13729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13730   int jresult ;
13731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13732   Dali::Property::Index result;
13733
13734   arg1 = (Dali::Property::Key *)jarg1;
13735   result = (Dali::Property::Index) ((arg1)->indexKey);
13736   jresult = result;
13737   return jresult;
13738 }
13739
13740
13741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13743   std::string *arg2 = 0 ;
13744
13745   arg1 = (Dali::Property::Key *)jarg1;
13746   if (!jarg2) {
13747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13748     return ;
13749   }
13750   std::string arg2_str(jarg2);
13751   arg2 = &arg2_str;
13752   if (arg1) (arg1)->stringKey = *arg2;
13753
13754   //argout typemap for const std::string&
13755
13756 }
13757
13758
13759 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13760   char * jresult ;
13761   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13762   std::string *result = 0 ;
13763
13764   arg1 = (Dali::Property::Key *)jarg1;
13765   result = (std::string *) & ((arg1)->stringKey);
13766   jresult = SWIG_csharp_string_callback(result->c_str());
13767   return jresult;
13768 }
13769
13770
13771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13772   void * jresult ;
13773   std::string *arg1 = 0 ;
13774   Dali::Property::Key *result = 0 ;
13775
13776   if (!jarg1) {
13777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13778     return 0;
13779   }
13780   std::string arg1_str(jarg1);
13781   arg1 = &arg1_str;
13782   {
13783     try {
13784       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13785     } catch (std::out_of_range& e) {
13786       {
13787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (std::exception& e) {
13790       {
13791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799   jresult = (void *)result;
13800
13801   //argout typemap for const std::string&
13802
13803   return jresult;
13804 }
13805
13806
13807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13808   void * jresult ;
13809   Dali::Property::Index arg1 ;
13810   Dali::Property::Key *result = 0 ;
13811
13812   arg1 = (Dali::Property::Index)jarg1;
13813   {
13814     try {
13815       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13816     } catch (std::out_of_range& e) {
13817       {
13818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (std::exception& e) {
13821       {
13822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830   jresult = (void *)result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13836   unsigned int jresult ;
13837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13838   std::string *arg2 = 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Property::Key *)jarg1;
13842   if (!jarg2) {
13843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13844     return 0;
13845   }
13846   std::string arg2_str(jarg2);
13847   arg2 = &arg2_str;
13848   {
13849     try {
13850       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13851     } catch (std::out_of_range& e) {
13852       {
13853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (std::exception& e) {
13856       {
13857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865   jresult = result;
13866
13867   //argout typemap for const std::string&
13868
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13874   unsigned int jresult ;
13875   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13876   Dali::Property::Index arg2 ;
13877   bool result;
13878
13879   arg1 = (Dali::Property::Key *)jarg1;
13880   arg2 = (Dali::Property::Index)jarg2;
13881   {
13882     try {
13883       result = (bool)(arg1)->operator ==(arg2);
13884     } catch (std::out_of_range& e) {
13885       {
13886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (std::exception& e) {
13889       {
13890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13895       };
13896     }
13897   }
13898   jresult = result;
13899   return jresult;
13900 }
13901
13902
13903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13904   unsigned int jresult ;
13905   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13906   Dali::Property::Key *arg2 = 0 ;
13907   bool result;
13908
13909   arg1 = (Dali::Property::Key *)jarg1;
13910   arg2 = (Dali::Property::Key *)jarg2;
13911   if (!arg2) {
13912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13913     return 0;
13914   }
13915   {
13916     try {
13917       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13918     } catch (std::out_of_range& e) {
13919       {
13920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (std::exception& e) {
13923       {
13924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932   jresult = result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13938   unsigned int jresult ;
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940   std::string *arg2 = 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Property::Key *)jarg1;
13944   if (!jarg2) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13946     return 0;
13947   }
13948   std::string arg2_str(jarg2);
13949   arg2 = &arg2_str;
13950   {
13951     try {
13952       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13953     } catch (std::out_of_range& e) {
13954       {
13955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13956       };
13957     } catch (std::exception& e) {
13958       {
13959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13960       };
13961     } catch (...) {
13962       {
13963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13964       };
13965     }
13966   }
13967   jresult = result;
13968
13969   //argout typemap for const std::string&
13970
13971   return jresult;
13972 }
13973
13974
13975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13976   unsigned int jresult ;
13977   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13978   Dali::Property::Index arg2 ;
13979   bool result;
13980
13981   arg1 = (Dali::Property::Key *)jarg1;
13982   arg2 = (Dali::Property::Index)jarg2;
13983   {
13984     try {
13985       result = (bool)(arg1)->operator !=(arg2);
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (...) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13997       };
13998     }
13999   }
14000   jresult = result;
14001   return jresult;
14002 }
14003
14004
14005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14006   unsigned int jresult ;
14007   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14008   Dali::Property::Key *arg2 = 0 ;
14009   bool result;
14010
14011   arg1 = (Dali::Property::Key *)jarg1;
14012   arg2 = (Dali::Property::Key *)jarg2;
14013   if (!arg2) {
14014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14015     return 0;
14016   }
14017   {
14018     try {
14019       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14020     } catch (std::out_of_range& e) {
14021       {
14022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14023       };
14024     } catch (std::exception& e) {
14025       {
14026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (...) {
14029       {
14030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14031       };
14032     }
14033   }
14034   jresult = result;
14035   return jresult;
14036 }
14037
14038
14039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14040   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14041
14042   arg1 = (Dali::Property::Key *)jarg1;
14043   {
14044     try {
14045       delete arg1;
14046     } catch (std::out_of_range& e) {
14047       {
14048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14049       };
14050     } catch (std::exception& e) {
14051       {
14052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14057       };
14058     }
14059   }
14060 }
14061
14062
14063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14064   void * jresult ;
14065   Dali::Property::Map *result = 0 ;
14066
14067   {
14068     try {
14069       result = (Dali::Property::Map *)new Dali::Property::Map();
14070     } catch (std::out_of_range& e) {
14071       {
14072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14073       };
14074     } catch (std::exception& e) {
14075       {
14076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14081       };
14082     }
14083   }
14084   jresult = (void *)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14090   void * jresult ;
14091   Dali::Property::Map *arg1 = 0 ;
14092   Dali::Property::Map *result = 0 ;
14093
14094   arg1 = (Dali::Property::Map *)jarg1;
14095   if (!arg1) {
14096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14097     return 0;
14098   }
14099   {
14100     try {
14101       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14102     } catch (std::out_of_range& e) {
14103       {
14104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14105       };
14106     } catch (std::exception& e) {
14107       {
14108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14109       };
14110     } catch (...) {
14111       {
14112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14113       };
14114     }
14115   }
14116   jresult = (void *)result;
14117   return jresult;
14118 }
14119
14120
14121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14122   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14123
14124   arg1 = (Dali::Property::Map *)jarg1;
14125   {
14126     try {
14127       delete arg1;
14128     } catch (std::out_of_range& e) {
14129       {
14130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14131       };
14132     } catch (std::exception& e) {
14133       {
14134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14135       };
14136     } catch (...) {
14137       {
14138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14139       };
14140     }
14141   }
14142 }
14143
14144
14145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14146   unsigned long jresult ;
14147   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14148   Dali::Property::Map::SizeType result;
14149
14150   arg1 = (Dali::Property::Map *)jarg1;
14151   {
14152     try {
14153       result = ((Dali::Property::Map const *)arg1)->Count();
14154     } catch (std::out_of_range& e) {
14155       {
14156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14157       };
14158     } catch (std::exception& e) {
14159       {
14160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14161       };
14162     } catch (...) {
14163       {
14164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14165       };
14166     }
14167   }
14168   jresult = (unsigned long)result;
14169   return jresult;
14170 }
14171
14172
14173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14174   unsigned int jresult ;
14175   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14176   bool result;
14177
14178   arg1 = (Dali::Property::Map *)jarg1;
14179   {
14180     try {
14181       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14182     } catch (std::out_of_range& e) {
14183       {
14184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14185       };
14186     } catch (std::exception& e) {
14187       {
14188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14189       };
14190     } catch (...) {
14191       {
14192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14193       };
14194     }
14195   }
14196   jresult = result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14202   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14203   char *arg2 = (char *) 0 ;
14204   Dali::Property::Value *arg3 = 0 ;
14205
14206   arg1 = (Dali::Property::Map *)jarg1;
14207   arg2 = (char *)jarg2;
14208   arg3 = (Dali::Property::Value *)jarg3;
14209   if (!arg3) {
14210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14211     return ;
14212   }
14213   {
14214     try {
14215       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14216     } catch (std::out_of_range& e) {
14217       {
14218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14219       };
14220     } catch (std::exception& e) {
14221       {
14222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14223       };
14224     } catch (...) {
14225       {
14226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14227       };
14228     }
14229   }
14230 }
14231
14232
14233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14235   Dali::Property::Index arg2 ;
14236   Dali::Property::Value *arg3 = 0 ;
14237
14238   arg1 = (Dali::Property::Map *)jarg1;
14239   arg2 = (Dali::Property::Index)jarg2;
14240   arg3 = (Dali::Property::Value *)jarg3;
14241   if (!arg3) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14243     return ;
14244   }
14245   {
14246     try {
14247       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14259       };
14260     }
14261   }
14262 }
14263
14264
14265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14266   void * jresult ;
14267   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14268   char *arg2 = (char *) 0 ;
14269   Dali::Property::Value *arg3 = 0 ;
14270   Dali::Property::Map *result = 0 ;
14271
14272   arg1 = (Dali::Property::Map *)jarg1;
14273   arg2 = (char *)jarg2;
14274   arg3 = (Dali::Property::Value *)jarg3;
14275   if (!arg3) {
14276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14277     return 0;
14278   }
14279   {
14280     try {
14281       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14282     } catch (std::out_of_range& e) {
14283       {
14284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (std::exception& e) {
14287       {
14288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14289       };
14290     } catch (...) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14293       };
14294     }
14295   }
14296   jresult = (void *)result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14302   void * jresult ;
14303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14304   Dali::Property::Index arg2 ;
14305   Dali::Property::Value *arg3 = 0 ;
14306   Dali::Property::Map *result = 0 ;
14307
14308   arg1 = (Dali::Property::Map *)jarg1;
14309   arg2 = (Dali::Property::Index)jarg2;
14310   arg3 = (Dali::Property::Value *)jarg3;
14311   if (!arg3) {
14312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14313     return 0;
14314   }
14315   {
14316     try {
14317       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332   jresult = (void *)result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14338   void * jresult ;
14339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14340   Dali::Property::Map::SizeType arg2 ;
14341   Dali::Property::Value *result = 0 ;
14342
14343   arg1 = (Dali::Property::Map *)jarg1;
14344   arg2 = (Dali::Property::Map::SizeType)jarg2;
14345   {
14346     try {
14347       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (...) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14359       };
14360     }
14361   }
14362   jresult = (void *)result;
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14368   char * jresult ;
14369   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14370   Dali::Property::Map::SizeType arg2 ;
14371   std::string *result = 0 ;
14372
14373   arg1 = (Dali::Property::Map *)jarg1;
14374   arg2 = (Dali::Property::Map::SizeType)jarg2;
14375   {
14376     try {
14377       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (...) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14389       };
14390     }
14391   }
14392   jresult = SWIG_csharp_string_callback(result->c_str());
14393   return jresult;
14394 }
14395
14396
14397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14398   void * jresult ;
14399   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14400   Dali::Property::Map::SizeType arg2 ;
14401   SwigValueWrapper< Dali::Property::Key > result;
14402
14403   arg1 = (Dali::Property::Map *)jarg1;
14404   arg2 = (Dali::Property::Map::SizeType)jarg2;
14405   {
14406     try {
14407       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14408     } catch (std::out_of_range& e) {
14409       {
14410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14411       };
14412     } catch (std::exception& e) {
14413       {
14414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14415       };
14416     } catch (...) {
14417       {
14418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14419       };
14420     }
14421   }
14422   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14428   void * jresult ;
14429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14430   Dali::Property::Map::SizeType arg2 ;
14431   StringValuePair *result = 0 ;
14432
14433   arg1 = (Dali::Property::Map *)jarg1;
14434   arg2 = (Dali::Property::Map::SizeType)jarg2;
14435   {
14436     try {
14437       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14438     } catch (std::out_of_range& e) {
14439       {
14440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (std::exception& e) {
14443       {
14444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (...) {
14447       {
14448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14449       };
14450     }
14451   }
14452   jresult = (void *)result;
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   char *arg2 = (char *) 0 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   arg2 = (char *)jarg2;
14465   {
14466     try {
14467       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14468     } catch (std::out_of_range& e) {
14469       {
14470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14471       };
14472     } catch (std::exception& e) {
14473       {
14474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14475       };
14476     } catch (...) {
14477       {
14478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14479       };
14480     }
14481   }
14482   jresult = (void *)result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14488   void * jresult ;
14489   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14490   Dali::Property::Index arg2 ;
14491   Dali::Property::Value *result = 0 ;
14492
14493   arg1 = (Dali::Property::Map *)jarg1;
14494   arg2 = (Dali::Property::Index)jarg2;
14495   {
14496     try {
14497       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14498     } catch (std::out_of_range& e) {
14499       {
14500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14501       };
14502     } catch (std::exception& e) {
14503       {
14504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14505       };
14506     } catch (...) {
14507       {
14508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14509       };
14510     }
14511   }
14512   jresult = (void *)result;
14513   return jresult;
14514 }
14515
14516
14517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14518   void * jresult ;
14519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14520   Dali::Property::Index arg2 ;
14521   std::string *arg3 = 0 ;
14522   Dali::Property::Value *result = 0 ;
14523
14524   arg1 = (Dali::Property::Map *)jarg1;
14525   arg2 = (Dali::Property::Index)jarg2;
14526   if (!jarg3) {
14527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14528     return 0;
14529   }
14530   std::string arg3_str(jarg3);
14531   arg3 = &arg3_str;
14532   {
14533     try {
14534       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14546       };
14547     }
14548   }
14549   jresult = (void *)result;
14550
14551   //argout typemap for const std::string&
14552
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14558   void * jresult ;
14559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14560   std::string *arg2 = 0 ;
14561   Dali::Property::Type arg3 ;
14562   Dali::Property::Value *result = 0 ;
14563
14564   arg1 = (Dali::Property::Map *)jarg1;
14565   if (!jarg2) {
14566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14567     return 0;
14568   }
14569   std::string arg2_str(jarg2);
14570   arg2 = &arg2_str;
14571   arg3 = (Dali::Property::Type)jarg3;
14572   {
14573     try {
14574       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14575     } catch (std::out_of_range& e) {
14576       {
14577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14578       };
14579     } catch (std::exception& e) {
14580       {
14581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14582       };
14583     } catch (...) {
14584       {
14585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14586       };
14587     }
14588   }
14589   jresult = (void *)result;
14590
14591   //argout typemap for const std::string&
14592
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14598   void * jresult ;
14599   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14600   Dali::Property::Index arg2 ;
14601   Dali::Property::Type arg3 ;
14602   Dali::Property::Value *result = 0 ;
14603
14604   arg1 = (Dali::Property::Map *)jarg1;
14605   arg2 = (Dali::Property::Index)jarg2;
14606   arg3 = (Dali::Property::Type)jarg3;
14607   {
14608     try {
14609       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14610     } catch (std::out_of_range& e) {
14611       {
14612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14613       };
14614     } catch (std::exception& e) {
14615       {
14616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14617       };
14618     } catch (...) {
14619       {
14620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14621       };
14622     }
14623   }
14624   jresult = (void *)result;
14625   return jresult;
14626 }
14627
14628
14629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14630   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14631
14632   arg1 = (Dali::Property::Map *)jarg1;
14633   {
14634     try {
14635       (arg1)->Clear();
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14643       };
14644     } catch (...) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14647       };
14648     }
14649   }
14650 }
14651
14652
14653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14654   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14655   Dali::Property::Map *arg2 = 0 ;
14656
14657   arg1 = (Dali::Property::Map *)jarg1;
14658   arg2 = (Dali::Property::Map *)jarg2;
14659   if (!arg2) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14661     return ;
14662   }
14663   {
14664     try {
14665       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14677       };
14678     }
14679   }
14680 }
14681
14682
14683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14684   void * jresult ;
14685   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14686   std::string *arg2 = 0 ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   arg1 = (Dali::Property::Map *)jarg1;
14690   if (!jarg2) {
14691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14692     return 0;
14693   }
14694   std::string arg2_str(jarg2);
14695   arg2 = &arg2_str;
14696   {
14697     try {
14698       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14699     } catch (std::out_of_range& e) {
14700       {
14701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14702       };
14703     } catch (std::exception& e) {
14704       {
14705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14706       };
14707     } catch (...) {
14708       {
14709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14710       };
14711     }
14712   }
14713   jresult = (void *)result;
14714
14715   //argout typemap for const std::string&
14716
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14722   void * jresult ;
14723   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14724   Dali::Property::Index arg2 ;
14725   Dali::Property::Value *result = 0 ;
14726
14727   arg1 = (Dali::Property::Map *)jarg1;
14728   arg2 = (Dali::Property::Index)jarg2;
14729   {
14730     try {
14731       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14732     } catch (std::out_of_range& e) {
14733       {
14734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14735       };
14736     } catch (std::exception& e) {
14737       {
14738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (...) {
14741       {
14742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14743       };
14744     }
14745   }
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14752   void * jresult ;
14753   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14754   Dali::Property::Map *arg2 = 0 ;
14755   Dali::Property::Map *result = 0 ;
14756
14757   arg1 = (Dali::Property::Map *)jarg1;
14758   arg2 = (Dali::Property::Map *)jarg2;
14759   if (!arg2) {
14760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14761     return 0;
14762   }
14763   {
14764     try {
14765       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14766     } catch (std::out_of_range& e) {
14767       {
14768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (std::exception& e) {
14771       {
14772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14786   void * jresult ;
14787   Dali::Property::Value *result = 0 ;
14788
14789   {
14790     try {
14791       result = (Dali::Property::Value *)new Dali::Property::Value();
14792     } catch (std::out_of_range& e) {
14793       {
14794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14795       };
14796     } catch (std::exception& e) {
14797       {
14798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14803       };
14804     }
14805   }
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14812   void * jresult ;
14813   bool arg1 ;
14814   Dali::Property::Value *result = 0 ;
14815
14816   arg1 = jarg1 ? true : false;
14817   {
14818     try {
14819       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14820     } catch (std::out_of_range& e) {
14821       {
14822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14823       };
14824     } catch (std::exception& e) {
14825       {
14826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14827       };
14828     } catch (...) {
14829       {
14830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14831       };
14832     }
14833   }
14834   jresult = (void *)result;
14835   return jresult;
14836 }
14837
14838
14839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14840   void * jresult ;
14841   int arg1 ;
14842   Dali::Property::Value *result = 0 ;
14843
14844   arg1 = (int)jarg1;
14845   {
14846     try {
14847       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14848     } catch (std::out_of_range& e) {
14849       {
14850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14851       };
14852     } catch (std::exception& e) {
14853       {
14854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14855       };
14856     } catch (...) {
14857       {
14858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14859       };
14860     }
14861   }
14862   jresult = (void *)result;
14863   return jresult;
14864 }
14865
14866
14867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14868   void * jresult ;
14869   float arg1 ;
14870   Dali::Property::Value *result = 0 ;
14871
14872   arg1 = (float)jarg1;
14873   {
14874     try {
14875       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14876     } catch (std::out_of_range& e) {
14877       {
14878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14879       };
14880     } catch (std::exception& e) {
14881       {
14882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14883       };
14884     } catch (...) {
14885       {
14886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14887       };
14888     }
14889   }
14890   jresult = (void *)result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14896   void * jresult ;
14897   Dali::Vector2 *arg1 = 0 ;
14898   Dali::Property::Value *result = 0 ;
14899
14900   arg1 = (Dali::Vector2 *)jarg1;
14901   if (!arg1) {
14902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14903     return 0;
14904   }
14905   {
14906     try {
14907       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14908     } catch (std::out_of_range& e) {
14909       {
14910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (std::exception& e) {
14913       {
14914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14915       };
14916     } catch (...) {
14917       {
14918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14919       };
14920     }
14921   }
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14928   void * jresult ;
14929   Dali::Vector3 *arg1 = 0 ;
14930   Dali::Property::Value *result = 0 ;
14931
14932   arg1 = (Dali::Vector3 *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (...) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14951       };
14952     }
14953   }
14954   jresult = (void *)result;
14955   return jresult;
14956 }
14957
14958
14959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14960   void * jresult ;
14961   Dali::Vector4 *arg1 = 0 ;
14962   Dali::Property::Value *result = 0 ;
14963
14964   arg1 = (Dali::Vector4 *)jarg1;
14965   if (!arg1) {
14966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14967     return 0;
14968   }
14969   {
14970     try {
14971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14972     } catch (std::out_of_range& e) {
14973       {
14974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14975       };
14976     } catch (std::exception& e) {
14977       {
14978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14983       };
14984     }
14985   }
14986   jresult = (void *)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14992   void * jresult ;
14993   Dali::Matrix3 *arg1 = 0 ;
14994   Dali::Property::Value *result = 0 ;
14995
14996   arg1 = (Dali::Matrix3 *)jarg1;
14997   if (!arg1) {
14998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14999     return 0;
15000   }
15001   {
15002     try {
15003       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15004     } catch (std::out_of_range& e) {
15005       {
15006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (std::exception& e) {
15009       {
15010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018   jresult = (void *)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15024   void * jresult ;
15025   Dali::Matrix *arg1 = 0 ;
15026   Dali::Property::Value *result = 0 ;
15027
15028   arg1 = (Dali::Matrix *)jarg1;
15029   if (!arg1) {
15030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15031     return 0;
15032   }
15033   {
15034     try {
15035       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15036     } catch (std::out_of_range& e) {
15037       {
15038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (std::exception& e) {
15041       {
15042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050   jresult = (void *)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15056   void * jresult ;
15057   Dali::Rect< int > *arg1 = 0 ;
15058   Dali::Property::Value *result = 0 ;
15059
15060   arg1 = (Dali::Rect< int > *)jarg1;
15061   if (!arg1) {
15062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15063     return 0;
15064   }
15065   {
15066     try {
15067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (...) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15079       };
15080     }
15081   }
15082   jresult = (void *)result;
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15088   void * jresult ;
15089   Dali::AngleAxis *arg1 = 0 ;
15090   Dali::Property::Value *result = 0 ;
15091
15092   arg1 = (Dali::AngleAxis *)jarg1;
15093   if (!arg1) {
15094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15095     return 0;
15096   }
15097   {
15098     try {
15099       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15100     } catch (std::out_of_range& e) {
15101       {
15102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15103       };
15104     } catch (std::exception& e) {
15105       {
15106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15111       };
15112     }
15113   }
15114   jresult = (void *)result;
15115   return jresult;
15116 }
15117
15118
15119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15120   void * jresult ;
15121   Dali::Quaternion *arg1 = 0 ;
15122   Dali::Property::Value *result = 0 ;
15123
15124   arg1 = (Dali::Quaternion *)jarg1;
15125   if (!arg1) {
15126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15127     return 0;
15128   }
15129   {
15130     try {
15131       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15132     } catch (std::out_of_range& e) {
15133       {
15134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15135       };
15136     } catch (std::exception& e) {
15137       {
15138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15143       };
15144     }
15145   }
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15152   void * jresult ;
15153   std::string *arg1 = 0 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   if (!jarg1) {
15157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15158     return 0;
15159   }
15160   std::string arg1_str(jarg1);
15161   arg1 = &arg1_str;
15162   {
15163     try {
15164       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15165     } catch (std::out_of_range& e) {
15166       {
15167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15168       };
15169     } catch (std::exception& e) {
15170       {
15171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15176       };
15177     }
15178   }
15179   jresult = (void *)result;
15180
15181   //argout typemap for const std::string&
15182
15183   return jresult;
15184 }
15185
15186
15187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15188   void * jresult ;
15189   Dali::Property::Array *arg1 = 0 ;
15190   Dali::Property::Value *result = 0 ;
15191
15192   arg1 = (Dali::Property::Array *)jarg1;
15193   if (!arg1) {
15194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15195     return 0;
15196   }
15197   {
15198     try {
15199       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15200     } catch (std::out_of_range& e) {
15201       {
15202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15203       };
15204     } catch (std::exception& e) {
15205       {
15206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15211       };
15212     }
15213   }
15214   jresult = (void *)result;
15215   return jresult;
15216 }
15217
15218
15219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15220   void * jresult ;
15221   Dali::Property::Map *arg1 = 0 ;
15222   Dali::Property::Value *result = 0 ;
15223
15224   arg1 = (Dali::Property::Map *)jarg1;
15225   if (!arg1) {
15226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15227     return 0;
15228   }
15229   {
15230     try {
15231       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15232     } catch (std::out_of_range& e) {
15233       {
15234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15235       };
15236     } catch (std::exception& e) {
15237       {
15238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15239       };
15240     } catch (...) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15243       };
15244     }
15245   }
15246   jresult = (void *)result;
15247   return jresult;
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15252   void * jresult ;
15253   Dali::Property::Type arg1 ;
15254   Dali::Property::Value *result = 0 ;
15255
15256   arg1 = (Dali::Property::Type)jarg1;
15257   {
15258     try {
15259       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15260     } catch (std::out_of_range& e) {
15261       {
15262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15263       };
15264     } catch (std::exception& e) {
15265       {
15266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (...) {
15269       {
15270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15271       };
15272     }
15273   }
15274   jresult = (void *)result;
15275   return jresult;
15276 }
15277
15278
15279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15280   void * jresult ;
15281   Dali::Property::Value *arg1 = 0 ;
15282   Dali::Property::Value *result = 0 ;
15283
15284   arg1 = (Dali::Property::Value *)jarg1;
15285   if (!arg1) {
15286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15287     return 0;
15288   }
15289   {
15290     try {
15291       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15292     } catch (std::out_of_range& e) {
15293       {
15294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (std::exception& e) {
15297       {
15298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15312   void * jresult ;
15313   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15314   Dali::Property::Value *arg2 = 0 ;
15315   Dali::Property::Value *result = 0 ;
15316
15317   arg1 = (Dali::Property::Value *)jarg1;
15318   arg2 = (Dali::Property::Value *)jarg2;
15319   if (!arg2) {
15320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15321     return 0;
15322   }
15323   {
15324     try {
15325       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (...) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15337       };
15338     }
15339   }
15340   jresult = (void *)result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15347
15348   arg1 = (Dali::Property::Value *)jarg1;
15349   {
15350     try {
15351       delete arg1;
15352     } catch (std::out_of_range& e) {
15353       {
15354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15355       };
15356     } catch (std::exception& e) {
15357       {
15358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15359       };
15360     } catch (...) {
15361       {
15362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15363       };
15364     }
15365   }
15366 }
15367
15368
15369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15370   int jresult ;
15371   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15372   Dali::Property::Type result;
15373
15374   arg1 = (Dali::Property::Value *)jarg1;
15375   {
15376     try {
15377       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15378     } catch (std::out_of_range& e) {
15379       {
15380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (std::exception& e) {
15383       {
15384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15385       };
15386     } catch (...) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15389       };
15390     }
15391   }
15392   jresult = (int)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15398   unsigned int jresult ;
15399   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15400   bool *arg2 = 0 ;
15401   bool result;
15402
15403   arg1 = (Dali::Property::Value *)jarg1;
15404   arg2 = (bool *)jarg2;
15405   {
15406     try {
15407       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15408     } catch (std::out_of_range& e) {
15409       {
15410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15411       };
15412     } catch (std::exception& e) {
15413       {
15414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15415       };
15416     } catch (...) {
15417       {
15418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15419       };
15420     }
15421   }
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15428   unsigned int jresult ;
15429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15430   float *arg2 = 0 ;
15431   bool result;
15432
15433   arg1 = (Dali::Property::Value *)jarg1;
15434   arg2 = (float *)jarg2;
15435   {
15436     try {
15437       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (...) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15449       };
15450     }
15451   }
15452   jresult = result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15458   unsigned int jresult ;
15459   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15460   int *arg2 = 0 ;
15461   bool result;
15462
15463   arg1 = (Dali::Property::Value *)jarg1;
15464   arg2 = (int *)jarg2;
15465   {
15466     try {
15467       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15468     } catch (std::out_of_range& e) {
15469       {
15470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15471       };
15472     } catch (std::exception& e) {
15473       {
15474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (...) {
15477       {
15478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15479       };
15480     }
15481   }
15482   jresult = result;
15483   return jresult;
15484 }
15485
15486
15487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15488   unsigned int jresult ;
15489   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15490   Dali::Rect< int > *arg2 = 0 ;
15491   bool result;
15492
15493   arg1 = (Dali::Property::Value *)jarg1;
15494   arg2 = (Dali::Rect< int > *)jarg2;
15495   if (!arg2) {
15496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15497     return 0;
15498   }
15499   {
15500     try {
15501       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15502     } catch (std::out_of_range& e) {
15503       {
15504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (std::exception& e) {
15507       {
15508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15509       };
15510     } catch (...) {
15511       {
15512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15513       };
15514     }
15515   }
15516   jresult = result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15522   unsigned int jresult ;
15523   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15524   Dali::Vector2 *arg2 = 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::Property::Value *)jarg1;
15528   arg2 = (Dali::Vector2 *)jarg2;
15529   if (!arg2) {
15530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15531     return 0;
15532   }
15533   {
15534     try {
15535       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15536     } catch (std::out_of_range& e) {
15537       {
15538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15539       };
15540     } catch (std::exception& e) {
15541       {
15542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (...) {
15545       {
15546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15547       };
15548     }
15549   }
15550   jresult = result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15556   unsigned int jresult ;
15557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15558   Dali::Vector3 *arg2 = 0 ;
15559   bool result;
15560
15561   arg1 = (Dali::Property::Value *)jarg1;
15562   arg2 = (Dali::Vector3 *)jarg2;
15563   if (!arg2) {
15564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15565     return 0;
15566   }
15567   {
15568     try {
15569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15570     } catch (std::out_of_range& e) {
15571       {
15572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (std::exception& e) {
15575       {
15576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15577       };
15578     } catch (...) {
15579       {
15580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15581       };
15582     }
15583   }
15584   jresult = result;
15585   return jresult;
15586 }
15587
15588
15589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15590   unsigned int jresult ;
15591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15592   Dali::Vector4 *arg2 = 0 ;
15593   bool result;
15594
15595   arg1 = (Dali::Property::Value *)jarg1;
15596   arg2 = (Dali::Vector4 *)jarg2;
15597   if (!arg2) {
15598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15599     return 0;
15600   }
15601   {
15602     try {
15603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15604     } catch (std::out_of_range& e) {
15605       {
15606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (std::exception& e) {
15609       {
15610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (...) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15615       };
15616     }
15617   }
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15626   Dali::Matrix3 *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Value *)jarg1;
15630   arg2 = (Dali::Matrix3 *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652   jresult = result;
15653   return jresult;
15654 }
15655
15656
15657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15658   unsigned int jresult ;
15659   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15660   Dali::Matrix *arg2 = 0 ;
15661   bool result;
15662
15663   arg1 = (Dali::Property::Value *)jarg1;
15664   arg2 = (Dali::Matrix *)jarg2;
15665   if (!arg2) {
15666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15667     return 0;
15668   }
15669   {
15670     try {
15671       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15683       };
15684     }
15685   }
15686   jresult = result;
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15694   Dali::AngleAxis *arg2 = 0 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Value *)jarg1;
15698   arg2 = (Dali::AngleAxis *)jarg2;
15699   if (!arg2) {
15700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15701     return 0;
15702   }
15703   {
15704     try {
15705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15706     } catch (std::out_of_range& e) {
15707       {
15708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (std::exception& e) {
15711       {
15712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (...) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15717       };
15718     }
15719   }
15720   jresult = result;
15721   return jresult;
15722 }
15723
15724
15725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15726   unsigned int jresult ;
15727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15728   Dali::Quaternion *arg2 = 0 ;
15729   bool result;
15730
15731   arg1 = (Dali::Property::Value *)jarg1;
15732   arg2 = (Dali::Quaternion *)jarg2;
15733   if (!arg2) {
15734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15735     return 0;
15736   }
15737   {
15738     try {
15739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15740     } catch (std::out_of_range& e) {
15741       {
15742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15743       };
15744     } catch (std::exception& e) {
15745       {
15746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (...) {
15749       {
15750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15751       };
15752     }
15753   }
15754   jresult = result;
15755   return jresult;
15756 }
15757
15758
15759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15760   unsigned int jresult ;
15761   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15762   std::string *arg2 = 0 ;
15763   bool result;
15764
15765   arg1 = (Dali::Property::Value *)jarg1;
15766
15767   //typemap in
15768   std::string temp;
15769   arg2 = &temp;
15770
15771   {
15772     try {
15773       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788   jresult = result;
15789
15790   //Typemap argout in c++ file.
15791   //This will convert c++ string to c# string
15792   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15793
15794   return jresult;
15795 }
15796
15797
15798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15799   unsigned int jresult ;
15800   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15801   Dali::Property::Array *arg2 = 0 ;
15802   bool result;
15803
15804   arg1 = (Dali::Property::Value *)jarg1;
15805   arg2 = (Dali::Property::Array *)jarg2;
15806   if (!arg2) {
15807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15808     return 0;
15809   }
15810   {
15811     try {
15812       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15813     } catch (std::out_of_range& e) {
15814       {
15815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (std::exception& e) {
15818       {
15819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827   jresult = result;
15828   return jresult;
15829 }
15830
15831
15832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15833   unsigned int jresult ;
15834   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15835   Dali::Property::Map *arg2 = 0 ;
15836   bool result;
15837
15838   arg1 = (Dali::Property::Value *)jarg1;
15839   arg2 = (Dali::Property::Map *)jarg2;
15840   if (!arg2) {
15841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15842     return 0;
15843   }
15844   {
15845     try {
15846       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15847     } catch (std::out_of_range& e) {
15848       {
15849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15850       };
15851     } catch (std::exception& e) {
15852       {
15853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (...) {
15856       {
15857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15858       };
15859     }
15860   }
15861   jresult = result;
15862   return jresult;
15863 }
15864
15865
15866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15867   void * jresult ;
15868   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15869   Dali::Property::Array *result = 0 ;
15870
15871   arg1 = (Dali::Property::Value *)jarg1;
15872   {
15873     try {
15874       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15875     } catch (std::out_of_range& e) {
15876       {
15877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15878       };
15879     } catch (std::exception& e) {
15880       {
15881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15882       };
15883     } catch (...) {
15884       {
15885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15886       };
15887     }
15888   }
15889   jresult = (void *)result;
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15895   void * jresult ;
15896   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15897   Dali::Property::Map *result = 0 ;
15898
15899   arg1 = (Dali::Property::Value *)jarg1;
15900   {
15901     try {
15902       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (...) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15914       };
15915     }
15916   }
15917   jresult = (void *)result;
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15923   char * jresult ;
15924   Dali::Property::Type arg1 ;
15925   char *result = 0 ;
15926
15927   arg1 = (Dali::Property::Type)jarg1;
15928   {
15929     try {
15930       result = (char *)Dali::PropertyTypes::GetName(arg1);
15931     } catch (std::out_of_range& e) {
15932       {
15933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15934       };
15935     } catch (std::exception& e) {
15936       {
15937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15938       };
15939     } catch (...) {
15940       {
15941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15942       };
15943     }
15944   }
15945   jresult = SWIG_csharp_string_callback((const char *)result);
15946   return jresult;
15947 }
15948
15949
15950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15951   unsigned int jresult ;
15952   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15953   std::string *arg2 = 0 ;
15954   Dali::Property::Map *arg3 = 0 ;
15955   bool result;
15956
15957   arg1 = (Dali::BaseObject *)jarg1;
15958   if (!jarg2) {
15959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15960     return 0;
15961   }
15962   std::string arg2_str(jarg2);
15963   arg2 = &arg2_str;
15964   arg3 = (Dali::Property::Map *)jarg3;
15965   if (!arg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15967     return 0;
15968   }
15969   {
15970     try {
15971       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15972     } catch (std::out_of_range& e) {
15973       {
15974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15975       };
15976     } catch (std::exception& e) {
15977       {
15978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (...) {
15981       {
15982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15983       };
15984     }
15985   }
15986   jresult = result;
15987
15988   //argout typemap for const std::string&
15989
15990   return jresult;
15991 }
15992
15993
15994 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15995   char * jresult ;
15996   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15997   std::string *result = 0 ;
15998
15999   arg1 = (Dali::BaseObject *)jarg1;
16000   {
16001     try {
16002       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16003     } catch (std::out_of_range& e) {
16004       {
16005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16006       };
16007     } catch (std::exception& e) {
16008       {
16009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16010       };
16011     } catch (...) {
16012       {
16013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16014       };
16015     }
16016   }
16017   jresult = SWIG_csharp_string_callback(result->c_str());
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16023   unsigned int jresult ;
16024   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16025   Dali::TypeInfo *arg2 = 0 ;
16026   bool result;
16027
16028   arg1 = (Dali::BaseObject *)jarg1;
16029   arg2 = (Dali::TypeInfo *)jarg2;
16030   if (!arg2) {
16031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16032     return 0;
16033   }
16034   {
16035     try {
16036       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16037     } catch (std::out_of_range& e) {
16038       {
16039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16040       };
16041     } catch (std::exception& e) {
16042       {
16043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16044       };
16045     } catch (...) {
16046       {
16047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16048       };
16049     }
16050   }
16051   jresult = result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16057   unsigned int jresult ;
16058   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16059   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16060   std::string *arg3 = 0 ;
16061   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16062   bool result;
16063
16064   arg1 = (Dali::BaseObject *)jarg1;
16065   arg2 = (ConnectionTrackerInterface *)jarg2;
16066   if (!jarg3) {
16067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16068     return 0;
16069   }
16070   std::string arg3_str(jarg3);
16071   arg3 = &arg3_str;
16072   arg4 = (FunctorDelegate *)jarg4;
16073   {
16074     try {
16075       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16076     } catch (std::out_of_range& e) {
16077       {
16078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16079       };
16080     } catch (std::exception& e) {
16081       {
16082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16087       };
16088     }
16089   }
16090   jresult = result;
16091
16092   //argout typemap for const std::string&
16093
16094   return jresult;
16095 }
16096
16097
16098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16099   void * jresult ;
16100   Dali::BaseHandle *arg1 = 0 ;
16101   Dali::BaseObject *result = 0 ;
16102
16103   arg1 = (Dali::BaseHandle *)jarg1;
16104   if (!arg1) {
16105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16106     return 0;
16107   }
16108   {
16109     try {
16110       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16111     } catch (std::out_of_range& e) {
16112       {
16113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (std::exception& e) {
16116       {
16117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16118       };
16119     } catch (...) {
16120       {
16121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16122       };
16123     }
16124   }
16125   jresult = (void *)result;
16126   return jresult;
16127 }
16128
16129
16130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16131   void * jresult ;
16132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16133   Dali::BaseHandle *result = 0 ;
16134
16135   arg1 = (Dali::BaseObject *)jarg1;
16136   {
16137     try {
16138       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16139     } catch (std::out_of_range& e) {
16140       {
16141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (std::exception& e) {
16144       {
16145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16159   void * jresult ;
16160   Dali::BaseHandle *result = 0 ;
16161
16162   {
16163     try {
16164       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16165     } catch (std::out_of_range& e) {
16166       {
16167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16168       };
16169     } catch (std::exception& e) {
16170       {
16171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16172       };
16173     } catch (...) {
16174       {
16175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16176       };
16177     }
16178   }
16179   jresult = (void *)result;
16180   return jresult;
16181 }
16182
16183
16184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16185   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16186
16187   arg1 = (Dali::BaseHandle *)jarg1;
16188   {
16189     try {
16190       delete arg1;
16191     } catch (std::out_of_range& e) {
16192       {
16193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16194       };
16195     } catch (std::exception& e) {
16196       {
16197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16198       };
16199     } catch (...) {
16200       {
16201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16202       };
16203     }
16204   }
16205 }
16206
16207
16208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16209   void * jresult ;
16210   Dali::BaseHandle *arg1 = 0 ;
16211   Dali::BaseHandle *result = 0 ;
16212
16213   arg1 = (Dali::BaseHandle *)jarg1;
16214   if (!arg1) {
16215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16216     return 0;
16217   }
16218   {
16219     try {
16220       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16221     } catch (std::out_of_range& e) {
16222       {
16223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (std::exception& e) {
16226       {
16227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (...) {
16230       {
16231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16232       };
16233     }
16234   }
16235   jresult = (void *)result;
16236   return jresult;
16237 }
16238
16239
16240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16241   void * jresult ;
16242   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16243   Dali::BaseHandle *arg2 = 0 ;
16244   Dali::BaseHandle *result = 0 ;
16245
16246   arg1 = (Dali::BaseHandle *)jarg1;
16247   arg2 = (Dali::BaseHandle *)jarg2;
16248   if (!arg2) {
16249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16250     return 0;
16251   }
16252   {
16253     try {
16254       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16255     } catch (std::out_of_range& e) {
16256       {
16257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16258       };
16259     } catch (std::exception& e) {
16260       {
16261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16262       };
16263     } catch (...) {
16264       {
16265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16266       };
16267     }
16268   }
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16275   unsigned int jresult ;
16276   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16277   std::string *arg2 = 0 ;
16278   Dali::Property::Map *arg3 = 0 ;
16279   bool result;
16280
16281   arg1 = (Dali::BaseHandle *)jarg1;
16282   if (!jarg2) {
16283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16284     return 0;
16285   }
16286   std::string arg2_str(jarg2);
16287   arg2 = &arg2_str;
16288   arg3 = (Dali::Property::Map *)jarg3;
16289   if (!arg3) {
16290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16291     return 0;
16292   }
16293   {
16294     try {
16295       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16296     } catch (std::out_of_range& e) {
16297       {
16298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16299       };
16300     } catch (std::exception& e) {
16301       {
16302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16303       };
16304     } catch (...) {
16305       {
16306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16307       };
16308     }
16309   }
16310   jresult = result;
16311
16312   //argout typemap for const std::string&
16313
16314   return jresult;
16315 }
16316
16317
16318 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16319   char * jresult ;
16320   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16321   std::string *result = 0 ;
16322
16323   arg1 = (Dali::BaseHandle *)jarg1;
16324   {
16325     try {
16326       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16327     } catch (std::out_of_range& e) {
16328       {
16329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16330       };
16331     } catch (std::exception& e) {
16332       {
16333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16334       };
16335     } catch (...) {
16336       {
16337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16338       };
16339     }
16340   }
16341   jresult = SWIG_csharp_string_callback(result->c_str());
16342   return jresult;
16343 }
16344
16345
16346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16347   unsigned int jresult ;
16348   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16349   Dali::TypeInfo *arg2 = 0 ;
16350   bool result;
16351
16352   arg1 = (Dali::BaseHandle *)jarg1;
16353   arg2 = (Dali::TypeInfo *)jarg2;
16354   if (!arg2) {
16355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16356     return 0;
16357   }
16358   {
16359     try {
16360       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16361     } catch (std::out_of_range& e) {
16362       {
16363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (std::exception& e) {
16366       {
16367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375   jresult = result;
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16381   void * jresult ;
16382   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16383   Dali::BaseObject *result = 0 ;
16384
16385   arg1 = (Dali::BaseHandle *)jarg1;
16386   {
16387     try {
16388       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16389     } catch (std::out_of_range& e) {
16390       {
16391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16392       };
16393     } catch (std::exception& e) {
16394       {
16395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (...) {
16398       {
16399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16400       };
16401     }
16402   }
16403   jresult = (void *)result;
16404   return jresult;
16405 }
16406
16407
16408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16409   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16410
16411   arg1 = (Dali::BaseHandle *)jarg1;
16412   {
16413     try {
16414       (arg1)->Reset();
16415     } catch (std::out_of_range& e) {
16416       {
16417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16418       };
16419     } catch (std::exception& e) {
16420       {
16421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16422       };
16423     } catch (...) {
16424       {
16425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16426       };
16427     }
16428   }
16429 }
16430
16431
16432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16433   unsigned int jresult ;
16434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16435   Dali::BaseHandle *arg2 = 0 ;
16436   bool result;
16437
16438   arg1 = (Dali::BaseHandle *)jarg1;
16439   arg2 = (Dali::BaseHandle *)jarg2;
16440   if (!arg2) {
16441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16442     return 0;
16443   }
16444   {
16445     try {
16446       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16447     } catch (std::out_of_range& e) {
16448       {
16449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (std::exception& e) {
16452       {
16453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (...) {
16456       {
16457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16458       };
16459     }
16460   }
16461   jresult = result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16467   unsigned int jresult ;
16468   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16469   Dali::BaseHandle *arg2 = 0 ;
16470   bool result;
16471
16472   arg1 = (Dali::BaseHandle *)jarg1;
16473   arg2 = (Dali::BaseHandle *)jarg2;
16474   if (!arg2) {
16475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16476     return 0;
16477   }
16478   {
16479     try {
16480       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16481     } catch (std::out_of_range& e) {
16482       {
16483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16484       };
16485     } catch (std::exception& e) {
16486       {
16487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (...) {
16490       {
16491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16492       };
16493     }
16494   }
16495   jresult = result;
16496   return jresult;
16497 }
16498
16499
16500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16501   void * jresult ;
16502   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16503   Dali::RefObject *result = 0 ;
16504
16505   arg1 = (Dali::BaseHandle *)jarg1;
16506   {
16507     try {
16508       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16509     } catch (std::out_of_range& e) {
16510       {
16511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16512       };
16513     } catch (std::exception& e) {
16514       {
16515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16520       };
16521     }
16522   }
16523   jresult = (void *)result;
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16529   unsigned int jresult ;
16530   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16531   bool result;
16532
16533   arg1 = (Dali::BaseHandle *)jarg1;
16534   {
16535     try {
16536       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16537     } catch (std::out_of_range& e) {
16538       {
16539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (std::exception& e) {
16542       {
16543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (...) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16548       };
16549     }
16550   }
16551   jresult = result;
16552   return jresult;
16553 }
16554
16555
16556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16557   unsigned int jresult ;
16558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16559   Dali::BaseHandle *arg2 = 0 ;
16560   bool result;
16561
16562   arg1 = (Dali::BaseHandle *)jarg1;
16563   arg2 = (Dali::BaseHandle *)jarg2;
16564   if (!arg2) {
16565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16566     return 0;
16567   }
16568   {
16569     try {
16570       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (...) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16582       };
16583     }
16584   }
16585   jresult = result;
16586   return jresult;
16587 }
16588
16589
16590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16591   unsigned int jresult ;
16592   Dali::BaseHandle *arg1 = 0 ;
16593   Dali::BaseHandle *arg2 = 0 ;
16594   bool result;
16595
16596   arg1 = (Dali::BaseHandle *)jarg1;
16597   if (!arg1) {
16598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16599     return 0;
16600   }
16601   arg2 = (Dali::BaseHandle *)jarg2;
16602   if (!arg2) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16604     return 0;
16605   }
16606   {
16607     try {
16608       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16609     } catch (std::out_of_range& e) {
16610       {
16611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16612       };
16613     } catch (std::exception& e) {
16614       {
16615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16616       };
16617     } catch (...) {
16618       {
16619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16620       };
16621     }
16622   }
16623   jresult = result;
16624   return jresult;
16625 }
16626
16627
16628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16629   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16630
16631   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16632   {
16633     try {
16634       delete arg1;
16635     } catch (std::out_of_range& e) {
16636       {
16637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16638       };
16639     } catch (std::exception& e) {
16640       {
16641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (...) {
16644       {
16645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16646       };
16647     }
16648   }
16649 }
16650
16651
16652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16653   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16654   SlotObserver *arg2 = (SlotObserver *) 0 ;
16655   CallbackBase *arg3 = (CallbackBase *) 0 ;
16656
16657   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16658   arg2 = (SlotObserver *)jarg2;
16659   arg3 = (CallbackBase *)jarg3;
16660   {
16661     try {
16662       (arg1)->SignalConnected(arg2,arg3);
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (...) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16674       };
16675     }
16676   }
16677 }
16678
16679
16680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16681   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16682
16683   arg1 = (Dali::SignalObserver *)jarg1;
16684   {
16685     try {
16686       delete arg1;
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16694       };
16695     } catch (...) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16698       };
16699     }
16700   }
16701 }
16702
16703
16704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16705   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16706   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16707   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16708
16709   arg1 = (Dali::SignalObserver *)jarg1;
16710   arg2 = (Dali::SlotObserver *)jarg2;
16711   arg3 = (Dali::CallbackBase *)jarg3;
16712   {
16713     try {
16714       (arg1)->SignalDisconnected(arg2,arg3);
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (...) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16726       };
16727     }
16728   }
16729 }
16730
16731
16732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16733   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16734
16735   arg1 = (Dali::SlotObserver *)jarg1;
16736   {
16737     try {
16738       delete arg1;
16739     } catch (std::out_of_range& e) {
16740       {
16741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16742       };
16743     } catch (std::exception& e) {
16744       {
16745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16746       };
16747     } catch (...) {
16748       {
16749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16750       };
16751     }
16752   }
16753 }
16754
16755
16756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16757   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16758   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16759
16760   arg1 = (Dali::SlotObserver *)jarg1;
16761   arg2 = (Dali::CallbackBase *)jarg2;
16762   {
16763     try {
16764       (arg1)->SlotDisconnected(arg2);
16765     } catch (std::out_of_range& e) {
16766       {
16767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16768       };
16769     } catch (std::exception& e) {
16770       {
16771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (...) {
16774       {
16775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16776       };
16777     }
16778   }
16779 }
16780
16781
16782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16783   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16784
16785   arg1 = (Dali::ConnectionTracker *)jarg1;
16786   {
16787     try {
16788       delete arg1;
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16800       };
16801     }
16802   }
16803 }
16804
16805
16806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16807   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16808
16809   arg1 = (Dali::ConnectionTracker *)jarg1;
16810   {
16811     try {
16812       (arg1)->DisconnectAll();
16813     } catch (std::out_of_range& e) {
16814       {
16815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16816       };
16817     } catch (std::exception& e) {
16818       {
16819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16820       };
16821     } catch (...) {
16822       {
16823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16824       };
16825     }
16826   }
16827 }
16828
16829
16830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16831   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16832   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16833   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16834
16835   arg1 = (Dali::ConnectionTracker *)jarg1;
16836   arg2 = (Dali::SlotObserver *)jarg2;
16837   arg3 = (Dali::CallbackBase *)jarg3;
16838   {
16839     try {
16840       (arg1)->SignalConnected(arg2,arg3);
16841     } catch (std::out_of_range& e) {
16842       {
16843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16844       };
16845     } catch (std::exception& e) {
16846       {
16847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16848       };
16849     } catch (...) {
16850       {
16851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16852       };
16853     }
16854   }
16855 }
16856
16857
16858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16859   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16860   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16861   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16862
16863   arg1 = (Dali::ConnectionTracker *)jarg1;
16864   arg2 = (Dali::SlotObserver *)jarg2;
16865   arg3 = (Dali::CallbackBase *)jarg3;
16866   {
16867     try {
16868       (arg1)->SignalDisconnected(arg2,arg3);
16869     } catch (std::out_of_range& e) {
16870       {
16871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16872       };
16873     } catch (std::exception& e) {
16874       {
16875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16876       };
16877     } catch (...) {
16878       {
16879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16880       };
16881     }
16882   }
16883 }
16884
16885
16886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16887   unsigned long jresult ;
16888   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16889   std::size_t result;
16890
16891   arg1 = (Dali::ConnectionTracker *)jarg1;
16892   {
16893     try {
16894       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (...) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16906       };
16907     }
16908   }
16909   jresult = (unsigned long)result;
16910   return jresult;
16911 }
16912
16913
16914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16915   void * jresult ;
16916   Dali::ObjectRegistry *result = 0 ;
16917
16918   {
16919     try {
16920       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16921     } catch (std::out_of_range& e) {
16922       {
16923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (std::exception& e) {
16926       {
16927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16928       };
16929     } catch (...) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16932       };
16933     }
16934   }
16935   jresult = (void *)result;
16936   return jresult;
16937 }
16938
16939
16940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16941   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16942
16943   arg1 = (Dali::ObjectRegistry *)jarg1;
16944   {
16945     try {
16946       delete arg1;
16947     } catch (std::out_of_range& e) {
16948       {
16949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16950       };
16951     } catch (std::exception& e) {
16952       {
16953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16954       };
16955     } catch (...) {
16956       {
16957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16958       };
16959     }
16960   }
16961 }
16962
16963
16964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16965   void * jresult ;
16966   Dali::ObjectRegistry *arg1 = 0 ;
16967   Dali::ObjectRegistry *result = 0 ;
16968
16969   arg1 = (Dali::ObjectRegistry *)jarg1;
16970   if (!arg1) {
16971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16972     return 0;
16973   }
16974   {
16975     try {
16976       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16977     } catch (std::out_of_range& e) {
16978       {
16979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (std::exception& e) {
16982       {
16983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16997   void * jresult ;
16998   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16999   Dali::ObjectRegistry *arg2 = 0 ;
17000   Dali::ObjectRegistry *result = 0 ;
17001
17002   arg1 = (Dali::ObjectRegistry *)jarg1;
17003   arg2 = (Dali::ObjectRegistry *)jarg2;
17004   if (!arg2) {
17005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17006     return 0;
17007   }
17008   {
17009     try {
17010       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17011     } catch (std::out_of_range& e) {
17012       {
17013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (std::exception& e) {
17016       {
17017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17031   void * jresult ;
17032   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17033   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17034
17035   arg1 = (Dali::ObjectRegistry *)jarg1;
17036   {
17037     try {
17038       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17039     } catch (std::out_of_range& e) {
17040       {
17041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17042       };
17043     } catch (std::exception& e) {
17044       {
17045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (...) {
17048       {
17049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17050       };
17051     }
17052   }
17053   jresult = (void *)result;
17054   return jresult;
17055 }
17056
17057
17058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17059   void * jresult ;
17060   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17061   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17062
17063   arg1 = (Dali::ObjectRegistry *)jarg1;
17064   {
17065     try {
17066       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081   jresult = (void *)result;
17082   return jresult;
17083 }
17084
17085
17086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17087   void * jresult ;
17088   Dali::PropertyCondition *result = 0 ;
17089
17090   {
17091     try {
17092       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17093     } catch (std::out_of_range& e) {
17094       {
17095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17096       };
17097     } catch (std::exception& e) {
17098       {
17099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17100       };
17101     } catch (...) {
17102       {
17103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17104       };
17105     }
17106   }
17107   jresult = (void *)result;
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17113   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17114
17115   arg1 = (Dali::PropertyCondition *)jarg1;
17116   {
17117     try {
17118       delete arg1;
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17126       };
17127     } catch (...) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17130       };
17131     }
17132   }
17133 }
17134
17135
17136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17137   void * jresult ;
17138   Dali::PropertyCondition *arg1 = 0 ;
17139   Dali::PropertyCondition *result = 0 ;
17140
17141   arg1 = (Dali::PropertyCondition *)jarg1;
17142   if (!arg1) {
17143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17144     return 0;
17145   }
17146   {
17147     try {
17148       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17149     } catch (std::out_of_range& e) {
17150       {
17151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (std::exception& e) {
17154       {
17155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17156       };
17157     } catch (...) {
17158       {
17159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17160       };
17161     }
17162   }
17163   jresult = (void *)result;
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17169   void * jresult ;
17170   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17171   Dali::PropertyCondition *arg2 = 0 ;
17172   Dali::PropertyCondition *result = 0 ;
17173
17174   arg1 = (Dali::PropertyCondition *)jarg1;
17175   arg2 = (Dali::PropertyCondition *)jarg2;
17176   if (!arg2) {
17177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17178     return 0;
17179   }
17180   {
17181     try {
17182       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17183     } catch (std::out_of_range& e) {
17184       {
17185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17186       };
17187     } catch (std::exception& e) {
17188       {
17189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (...) {
17192       {
17193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17194       };
17195     }
17196   }
17197   jresult = (void *)result;
17198   return jresult;
17199 }
17200
17201
17202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17203   unsigned long jresult ;
17204   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17205   std::size_t result;
17206
17207   arg1 = (Dali::PropertyCondition *)jarg1;
17208   {
17209     try {
17210       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17211     } catch (std::out_of_range& e) {
17212       {
17213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17214       };
17215     } catch (std::exception& e) {
17216       {
17217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (...) {
17220       {
17221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17222       };
17223     }
17224   }
17225   jresult = (unsigned long)result;
17226   return jresult;
17227 }
17228
17229
17230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17231   float jresult ;
17232   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17233   std::size_t arg2 ;
17234   float result;
17235
17236   arg1 = (Dali::PropertyCondition *)jarg1;
17237   arg2 = (std::size_t)jarg2;
17238   {
17239     try {
17240       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17241     } catch (std::out_of_range& e) {
17242       {
17243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17244       };
17245     } catch (std::exception& e) {
17246       {
17247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (...) {
17250       {
17251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17252       };
17253     }
17254   }
17255   jresult = result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17261   void * jresult ;
17262   float arg1 ;
17263   Dali::PropertyCondition result;
17264
17265   arg1 = (float)jarg1;
17266   {
17267     try {
17268       result = Dali::LessThanCondition(arg1);
17269     } catch (std::out_of_range& e) {
17270       {
17271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17272       };
17273     } catch (std::exception& e) {
17274       {
17275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (...) {
17278       {
17279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17280       };
17281     }
17282   }
17283   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17289   void * jresult ;
17290   float arg1 ;
17291   Dali::PropertyCondition result;
17292
17293   arg1 = (float)jarg1;
17294   {
17295     try {
17296       result = Dali::GreaterThanCondition(arg1);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (...) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17308       };
17309     }
17310   }
17311   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17312   return jresult;
17313 }
17314
17315
17316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17317   void * jresult ;
17318   float arg1 ;
17319   float arg2 ;
17320   Dali::PropertyCondition result;
17321
17322   arg1 = (float)jarg1;
17323   arg2 = (float)jarg2;
17324   {
17325     try {
17326       result = Dali::InsideCondition(arg1,arg2);
17327     } catch (std::out_of_range& e) {
17328       {
17329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (std::exception& e) {
17332       {
17333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17347   void * jresult ;
17348   float arg1 ;
17349   float arg2 ;
17350   Dali::PropertyCondition result;
17351
17352   arg1 = (float)jarg1;
17353   arg2 = (float)jarg2;
17354   {
17355     try {
17356       result = Dali::OutsideCondition(arg1,arg2);
17357     } catch (std::out_of_range& e) {
17358       {
17359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17360       };
17361     } catch (std::exception& e) {
17362       {
17363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (...) {
17366       {
17367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17368       };
17369     }
17370   }
17371   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17372   return jresult;
17373 }
17374
17375
17376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17377   void * jresult ;
17378   float arg1 ;
17379   float arg2 ;
17380   Dali::PropertyCondition result;
17381
17382   arg1 = (float)jarg1;
17383   arg2 = (float)jarg2;
17384   {
17385     try {
17386       result = Dali::StepCondition(arg1,arg2);
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (...) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17398       };
17399     }
17400   }
17401   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17402   return jresult;
17403 }
17404
17405
17406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17407   void * jresult ;
17408   float arg1 ;
17409   Dali::PropertyCondition result;
17410
17411   arg1 = (float)jarg1;
17412   {
17413     try {
17414       result = Dali::StepCondition(arg1);
17415     } catch (std::out_of_range& e) {
17416       {
17417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17418       };
17419     } catch (std::exception& e) {
17420       {
17421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17422       };
17423     } catch (...) {
17424       {
17425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17426       };
17427     }
17428   }
17429   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17430   return jresult;
17431 }
17432
17433
17434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17435   void * jresult ;
17436   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17437   Dali::PropertyCondition result;
17438
17439   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17440   if (!arg1) {
17441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17442     return 0;
17443   }
17444   {
17445     try {
17446       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17447     } catch (std::out_of_range& e) {
17448       {
17449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17450       };
17451     } catch (std::exception& e) {
17452       {
17453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17454       };
17455     } catch (...) {
17456       {
17457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17458       };
17459     }
17460   }
17461   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17462   return jresult;
17463 }
17464
17465
17466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17467   void * jresult ;
17468   Dali::PropertyNotification *result = 0 ;
17469
17470   {
17471     try {
17472       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17473     } catch (std::out_of_range& e) {
17474       {
17475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (std::exception& e) {
17478       {
17479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487   jresult = (void *)result;
17488   return jresult;
17489 }
17490
17491
17492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17493   void * jresult ;
17494   Dali::BaseHandle arg1 ;
17495   Dali::BaseHandle *argp1 ;
17496   Dali::PropertyNotification result;
17497
17498   argp1 = (Dali::BaseHandle *)jarg1;
17499   if (!argp1) {
17500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17501     return 0;
17502   }
17503   arg1 = *argp1;
17504   {
17505     try {
17506       result = Dali::PropertyNotification::DownCast(arg1);
17507     } catch (std::out_of_range& e) {
17508       {
17509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (std::exception& e) {
17512       {
17513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (...) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17518       };
17519     }
17520   }
17521   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17522   return jresult;
17523 }
17524
17525
17526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17527   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17528
17529   arg1 = (Dali::PropertyNotification *)jarg1;
17530   {
17531     try {
17532       delete arg1;
17533     } catch (std::out_of_range& e) {
17534       {
17535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17536       };
17537     } catch (std::exception& e) {
17538       {
17539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17544       };
17545     }
17546   }
17547 }
17548
17549
17550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17551   void * jresult ;
17552   Dali::PropertyNotification *arg1 = 0 ;
17553   Dali::PropertyNotification *result = 0 ;
17554
17555   arg1 = (Dali::PropertyNotification *)jarg1;
17556   if (!arg1) {
17557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17558     return 0;
17559   }
17560   {
17561     try {
17562       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17563     } catch (std::out_of_range& e) {
17564       {
17565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17566       };
17567     } catch (std::exception& e) {
17568       {
17569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (...) {
17572       {
17573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17574       };
17575     }
17576   }
17577   jresult = (void *)result;
17578   return jresult;
17579 }
17580
17581
17582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17583   void * jresult ;
17584   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17585   Dali::PropertyNotification *arg2 = 0 ;
17586   Dali::PropertyNotification *result = 0 ;
17587
17588   arg1 = (Dali::PropertyNotification *)jarg1;
17589   arg2 = (Dali::PropertyNotification *)jarg2;
17590   if (!arg2) {
17591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17592     return 0;
17593   }
17594   {
17595     try {
17596       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17597     } catch (std::out_of_range& e) {
17598       {
17599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17600       };
17601     } catch (std::exception& e) {
17602       {
17603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (...) {
17606       {
17607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17608       };
17609     }
17610   }
17611   jresult = (void *)result;
17612   return jresult;
17613 }
17614
17615
17616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17617   void * jresult ;
17618   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17619   Dali::PropertyCondition result;
17620
17621   arg1 = (Dali::PropertyNotification *)jarg1;
17622   {
17623     try {
17624       result = (arg1)->GetCondition();
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (...) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17636       };
17637     }
17638   }
17639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17645   void * jresult ;
17646   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17647   Dali::Handle result;
17648
17649   arg1 = (Dali::PropertyNotification *)jarg1;
17650   {
17651     try {
17652       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17653     } catch (std::out_of_range& e) {
17654       {
17655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17656       };
17657     } catch (std::exception& e) {
17658       {
17659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17660       };
17661     } catch (...) {
17662       {
17663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17664       };
17665     }
17666   }
17667   jresult = new Dali::Handle((const Dali::Handle &)result);
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17673   int jresult ;
17674   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17675   Dali::Property::Index result;
17676
17677   arg1 = (Dali::PropertyNotification *)jarg1;
17678   {
17679     try {
17680       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17681     } catch (std::out_of_range& e) {
17682       {
17683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (std::exception& e) {
17686       {
17687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (...) {
17690       {
17691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17692       };
17693     }
17694   }
17695   jresult = result;
17696   return jresult;
17697 }
17698
17699
17700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17701   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17702   Dali::PropertyNotification::NotifyMode arg2 ;
17703
17704   arg1 = (Dali::PropertyNotification *)jarg1;
17705   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17706   {
17707     try {
17708       (arg1)->SetNotifyMode(arg2);
17709     } catch (std::out_of_range& e) {
17710       {
17711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17712       };
17713     } catch (std::exception& e) {
17714       {
17715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17716       };
17717     } catch (...) {
17718       {
17719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17720       };
17721     }
17722   }
17723 }
17724
17725
17726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17727   int jresult ;
17728   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17729   Dali::PropertyNotification::NotifyMode result;
17730
17731   arg1 = (Dali::PropertyNotification *)jarg1;
17732   {
17733     try {
17734       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17735     } catch (std::out_of_range& e) {
17736       {
17737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17738       };
17739     } catch (std::exception& e) {
17740       {
17741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (...) {
17744       {
17745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17746       };
17747     }
17748   }
17749   jresult = (int)result;
17750   return jresult;
17751 }
17752
17753
17754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17755   unsigned int jresult ;
17756   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17757   bool result;
17758
17759   arg1 = (Dali::PropertyNotification *)jarg1;
17760   {
17761     try {
17762       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (...) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17774       };
17775     }
17776   }
17777   jresult = result;
17778   return jresult;
17779 }
17780
17781
17782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17783   void * jresult ;
17784   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17785   Dali::PropertyNotifySignalType *result = 0 ;
17786
17787   arg1 = (Dali::PropertyNotification *)jarg1;
17788   {
17789     try {
17790       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17791     } catch (std::out_of_range& e) {
17792       {
17793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17794       };
17795     } catch (std::exception& e) {
17796       {
17797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17798       };
17799     } catch (...) {
17800       {
17801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17802       };
17803     }
17804   }
17805   jresult = (void *)result;
17806   return jresult;
17807 }
17808
17809
17810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17811   void * jresult ;
17812   Dali::Handle *result = 0 ;
17813
17814   {
17815     try {
17816       result = (Dali::Handle *)new Dali::Handle();
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (...) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17828       };
17829     }
17830   }
17831   jresult = (void *)result;
17832   return jresult;
17833 }
17834
17835
17836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17837   void * jresult ;
17838   Dali::Handle result;
17839
17840   {
17841     try {
17842       result = Dali::Handle::New();
17843     } catch (std::out_of_range& e) {
17844       {
17845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (std::exception& e) {
17848       {
17849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17850       };
17851     } catch (...) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17854       };
17855     }
17856   }
17857   jresult = new Dali::Handle((const Dali::Handle &)result);
17858   return jresult;
17859 }
17860
17861
17862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17863   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17864
17865   arg1 = (Dali::Handle *)jarg1;
17866   {
17867     try {
17868       delete arg1;
17869     } catch (std::out_of_range& e) {
17870       {
17871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17872       };
17873     } catch (std::exception& e) {
17874       {
17875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17880       };
17881     }
17882   }
17883 }
17884
17885
17886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17887   void * jresult ;
17888   Dali::Handle *arg1 = 0 ;
17889   Dali::Handle *result = 0 ;
17890
17891   arg1 = (Dali::Handle *)jarg1;
17892   if (!arg1) {
17893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17894     return 0;
17895   }
17896   {
17897     try {
17898       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17899     } catch (std::out_of_range& e) {
17900       {
17901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (std::exception& e) {
17904       {
17905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (...) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17910       };
17911     }
17912   }
17913   jresult = (void *)result;
17914   return jresult;
17915 }
17916
17917
17918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17919   void * jresult ;
17920   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17921   Dali::Handle *arg2 = 0 ;
17922   Dali::Handle *result = 0 ;
17923
17924   arg1 = (Dali::Handle *)jarg1;
17925   arg2 = (Dali::Handle *)jarg2;
17926   if (!arg2) {
17927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17928     return 0;
17929   }
17930   {
17931     try {
17932       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17933     } catch (std::out_of_range& e) {
17934       {
17935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17936       };
17937     } catch (std::exception& e) {
17938       {
17939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (...) {
17942       {
17943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17944       };
17945     }
17946   }
17947   jresult = (void *)result;
17948   return jresult;
17949 }
17950
17951
17952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17953   void * jresult ;
17954   Dali::BaseHandle arg1 ;
17955   Dali::BaseHandle *argp1 ;
17956   Dali::Handle result;
17957
17958   argp1 = (Dali::BaseHandle *)jarg1;
17959   if (!argp1) {
17960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17961     return 0;
17962   }
17963   arg1 = *argp1;
17964   {
17965     try {
17966       result = Dali::Handle::DownCast(arg1);
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (...) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17978       };
17979     }
17980   }
17981   jresult = new Dali::Handle((const Dali::Handle &)result);
17982   return jresult;
17983 }
17984
17985
17986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17987   unsigned int jresult ;
17988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17989   Dali::Handle::Capability arg2 ;
17990   bool result;
17991
17992   arg1 = (Dali::Handle *)jarg1;
17993   arg2 = (Dali::Handle::Capability)jarg2;
17994   {
17995     try {
17996       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17997     } catch (std::out_of_range& e) {
17998       {
17999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18000       };
18001     } catch (std::exception& e) {
18002       {
18003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (...) {
18006       {
18007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18008       };
18009     }
18010   }
18011   jresult = result;
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18017   unsigned int jresult ;
18018   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18019   unsigned int result;
18020
18021   arg1 = (Dali::Handle *)jarg1;
18022   {
18023     try {
18024       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18025     } catch (std::out_of_range& e) {
18026       {
18027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18028       };
18029     } catch (std::exception& e) {
18030       {
18031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18032       };
18033     } catch (...) {
18034       {
18035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18036       };
18037     }
18038   }
18039   jresult = result;
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18045   char * jresult ;
18046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18047   Dali::Property::Index arg2 ;
18048   std::string result;
18049
18050   arg1 = (Dali::Handle *)jarg1;
18051   arg2 = (Dali::Property::Index)jarg2;
18052   {
18053     try {
18054       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18055     } catch (std::out_of_range& e) {
18056       {
18057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18058       };
18059     } catch (std::exception& e) {
18060       {
18061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (...) {
18064       {
18065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18066       };
18067     }
18068   }
18069   jresult = SWIG_csharp_string_callback((&result)->c_str());
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18075   int jresult ;
18076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18077   std::string *arg2 = 0 ;
18078   Dali::Property::Index result;
18079
18080   arg1 = (Dali::Handle *)jarg1;
18081   if (!jarg2) {
18082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18083     return 0;
18084   }
18085   std::string arg2_str(jarg2);
18086   arg2 = &arg2_str;
18087   {
18088     try {
18089       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18090     } catch (std::out_of_range& e) {
18091       {
18092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18093       };
18094     } catch (std::exception& e) {
18095       {
18096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (...) {
18099       {
18100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18101       };
18102     }
18103   }
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18113   unsigned int jresult ;
18114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18115   Dali::Property::Index arg2 ;
18116   bool result;
18117
18118   arg1 = (Dali::Handle *)jarg1;
18119   arg2 = (Dali::Property::Index)jarg2;
18120   {
18121     try {
18122       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18123     } catch (std::out_of_range& e) {
18124       {
18125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (std::exception& e) {
18128       {
18129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137   jresult = result;
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18143   unsigned int jresult ;
18144   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18145   Dali::Property::Index arg2 ;
18146   bool result;
18147
18148   arg1 = (Dali::Handle *)jarg1;
18149   arg2 = (Dali::Property::Index)jarg2;
18150   {
18151     try {
18152       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18153     } catch (std::out_of_range& e) {
18154       {
18155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18156       };
18157     } catch (std::exception& e) {
18158       {
18159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (...) {
18162       {
18163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18164       };
18165     }
18166   }
18167   jresult = result;
18168   return jresult;
18169 }
18170
18171
18172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18173   unsigned int jresult ;
18174   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18175   Dali::Property::Index arg2 ;
18176   bool result;
18177
18178   arg1 = (Dali::Handle *)jarg1;
18179   arg2 = (Dali::Property::Index)jarg2;
18180   {
18181     try {
18182       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18183     } catch (std::out_of_range& e) {
18184       {
18185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (std::exception& e) {
18188       {
18189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197   jresult = result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18203   int jresult ;
18204   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18205   Dali::Property::Index arg2 ;
18206   Dali::Property::Type result;
18207
18208   arg1 = (Dali::Handle *)jarg1;
18209   arg2 = (Dali::Property::Index)jarg2;
18210   {
18211     try {
18212       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18213     } catch (std::out_of_range& e) {
18214       {
18215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18216       };
18217     } catch (std::exception& e) {
18218       {
18219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18220       };
18221     } catch (...) {
18222       {
18223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18224       };
18225     }
18226   }
18227   jresult = (int)result;
18228   return jresult;
18229 }
18230
18231
18232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18233   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18234   Dali::Property::Index arg2 ;
18235   Dali::Property::Value *arg3 = 0 ;
18236
18237   arg1 = (Dali::Handle *)jarg1;
18238   arg2 = (Dali::Property::Index)jarg2;
18239   arg3 = (Dali::Property::Value *)jarg3;
18240   if (!arg3) {
18241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18242     return ;
18243   }
18244   {
18245     try {
18246       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18247     } catch (std::out_of_range& e) {
18248       {
18249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18250       };
18251     } catch (std::exception& e) {
18252       {
18253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18254       };
18255     } catch (...) {
18256       {
18257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18258       };
18259     }
18260   }
18261 }
18262
18263
18264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18265   int jresult ;
18266   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18267   std::string *arg2 = 0 ;
18268   Dali::Property::Value *arg3 = 0 ;
18269   Dali::Property::Index result;
18270
18271   arg1 = (Dali::Handle *)jarg1;
18272   if (!jarg2) {
18273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18274     return 0;
18275   }
18276   std::string arg2_str(jarg2);
18277   arg2 = &arg2_str;
18278   arg3 = (Dali::Property::Value *)jarg3;
18279   if (!arg3) {
18280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18281     return 0;
18282   }
18283   {
18284     try {
18285       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18286     } catch (std::out_of_range& e) {
18287       {
18288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18289       };
18290     } catch (std::exception& e) {
18291       {
18292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18293       };
18294     } catch (...) {
18295       {
18296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18297       };
18298     }
18299   }
18300   jresult = result;
18301
18302   //argout typemap for const std::string&
18303
18304   return jresult;
18305 }
18306
18307
18308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18309   int jresult ;
18310   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18311   std::string *arg2 = 0 ;
18312   Dali::Property::Value *arg3 = 0 ;
18313   Dali::Property::AccessMode arg4 ;
18314   Dali::Property::Index result;
18315
18316   arg1 = (Dali::Handle *)jarg1;
18317   if (!jarg2) {
18318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18319     return 0;
18320   }
18321   std::string arg2_str(jarg2);
18322   arg2 = &arg2_str;
18323   arg3 = (Dali::Property::Value *)jarg3;
18324   if (!arg3) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18326     return 0;
18327   }
18328   arg4 = (Dali::Property::AccessMode)jarg4;
18329   {
18330     try {
18331       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18332     } catch (std::out_of_range& e) {
18333       {
18334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (std::exception& e) {
18337       {
18338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346   jresult = result;
18347
18348   //argout typemap for const std::string&
18349
18350   return jresult;
18351 }
18352
18353
18354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18355   void * jresult ;
18356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18357   Dali::Property::Index arg2 ;
18358   Dali::Property::Value result;
18359
18360   arg1 = (Dali::Handle *)jarg1;
18361   arg2 = (Dali::Property::Index)jarg2;
18362   {
18363     try {
18364       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18365     } catch (std::out_of_range& e) {
18366       {
18367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18368       };
18369     } catch (std::exception& e) {
18370       {
18371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (...) {
18374       {
18375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18376       };
18377     }
18378   }
18379   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18380   return jresult;
18381 }
18382
18383
18384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18385   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18386   Dali::Property::IndexContainer *arg2 = 0 ;
18387
18388   arg1 = (Dali::Handle *)jarg1;
18389   arg2 = (Dali::Property::IndexContainer *)jarg2;
18390   if (!arg2) {
18391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18392     return ;
18393   }
18394   {
18395     try {
18396       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18397     } catch (std::out_of_range& e) {
18398       {
18399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18400       };
18401     } catch (std::exception& e) {
18402       {
18403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18408       };
18409     }
18410   }
18411 }
18412
18413
18414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18415   void * jresult ;
18416   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18417   Dali::Property::Index arg2 ;
18418   Dali::PropertyCondition *arg3 = 0 ;
18419   Dali::PropertyNotification result;
18420
18421   arg1 = (Dali::Handle *)jarg1;
18422   arg2 = (Dali::Property::Index)jarg2;
18423   arg3 = (Dali::PropertyCondition *)jarg3;
18424   if (!arg3) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (...) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18442       };
18443     }
18444   }
18445   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18446   return jresult;
18447 }
18448
18449
18450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18451   void * jresult ;
18452   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18453   Dali::Property::Index arg2 ;
18454   int arg3 ;
18455   Dali::PropertyCondition *arg4 = 0 ;
18456   Dali::PropertyNotification result;
18457
18458   arg1 = (Dali::Handle *)jarg1;
18459   arg2 = (Dali::Property::Index)jarg2;
18460   arg3 = (int)jarg3;
18461   arg4 = (Dali::PropertyCondition *)jarg4;
18462   if (!arg4) {
18463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18464     return 0;
18465   }
18466   {
18467     try {
18468       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18469     } catch (std::out_of_range& e) {
18470       {
18471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18472       };
18473     } catch (std::exception& e) {
18474       {
18475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18476       };
18477     } catch (...) {
18478       {
18479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18480       };
18481     }
18482   }
18483   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18484   return jresult;
18485 }
18486
18487
18488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18490   Dali::PropertyNotification arg2 ;
18491   Dali::PropertyNotification *argp2 ;
18492
18493   arg1 = (Dali::Handle *)jarg1;
18494   argp2 = (Dali::PropertyNotification *)jarg2;
18495   if (!argp2) {
18496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18497     return ;
18498   }
18499   arg2 = *argp2;
18500   {
18501     try {
18502       (arg1)->RemovePropertyNotification(arg2);
18503     } catch (std::out_of_range& e) {
18504       {
18505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18506       };
18507     } catch (std::exception& e) {
18508       {
18509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (...) {
18512       {
18513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18514       };
18515     }
18516   }
18517 }
18518
18519
18520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18521   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18522
18523   arg1 = (Dali::Handle *)jarg1;
18524   {
18525     try {
18526       (arg1)->RemovePropertyNotifications();
18527     } catch (std::out_of_range& e) {
18528       {
18529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18530       };
18531     } catch (std::exception& e) {
18532       {
18533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (...) {
18536       {
18537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18538       };
18539     }
18540   }
18541 }
18542
18543
18544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18545   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18546
18547   arg1 = (Dali::Handle *)jarg1;
18548   {
18549     try {
18550       (arg1)->RemoveConstraints();
18551     } catch (std::out_of_range& e) {
18552       {
18553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18554       };
18555     } catch (std::exception& e) {
18556       {
18557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18558       };
18559     } catch (...) {
18560       {
18561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18562       };
18563     }
18564   }
18565 }
18566
18567
18568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18569   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18570   unsigned int arg2 ;
18571
18572   arg1 = (Dali::Handle *)jarg1;
18573   arg2 = (unsigned int)jarg2;
18574   {
18575     try {
18576       (arg1)->RemoveConstraints(arg2);
18577     } catch (std::out_of_range& e) {
18578       {
18579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18580       };
18581     } catch (std::exception& e) {
18582       {
18583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18584       };
18585     } catch (...) {
18586       {
18587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18588       };
18589     }
18590   }
18591 }
18592
18593
18594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18595   int jresult ;
18596   Dali::Property::Index result;
18597
18598   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18599   jresult = result;
18600   return jresult;
18601 }
18602
18603
18604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18605   void * jresult ;
18606   Dali::Handle result;
18607
18608   {
18609     try {
18610       result = Dali::WeightObject::New();
18611     } catch (std::out_of_range& e) {
18612       {
18613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18614       };
18615     } catch (std::exception& e) {
18616       {
18617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18618       };
18619     } catch (...) {
18620       {
18621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18622       };
18623     }
18624   }
18625   jresult = new Dali::Handle((const Dali::Handle &)result);
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18631   void * jresult ;
18632   Dali::TypeInfo *result = 0 ;
18633
18634   {
18635     try {
18636       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18637     } catch (std::out_of_range& e) {
18638       {
18639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (std::exception& e) {
18642       {
18643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651   jresult = (void *)result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18657   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18658
18659   arg1 = (Dali::TypeInfo *)jarg1;
18660   {
18661     try {
18662       delete arg1;
18663     } catch (std::out_of_range& e) {
18664       {
18665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18666       };
18667     } catch (std::exception& e) {
18668       {
18669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18670       };
18671     } catch (...) {
18672       {
18673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18674       };
18675     }
18676   }
18677 }
18678
18679
18680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18681   void * jresult ;
18682   Dali::TypeInfo *arg1 = 0 ;
18683   Dali::TypeInfo *result = 0 ;
18684
18685   arg1 = (Dali::TypeInfo *)jarg1;
18686   if (!arg1) {
18687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18688     return 0;
18689   }
18690   {
18691     try {
18692       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18693     } catch (std::out_of_range& e) {
18694       {
18695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (std::exception& e) {
18698       {
18699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18700       };
18701     } catch (...) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18704       };
18705     }
18706   }
18707   jresult = (void *)result;
18708   return jresult;
18709 }
18710
18711
18712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18713   void * jresult ;
18714   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18715   Dali::TypeInfo *arg2 = 0 ;
18716   Dali::TypeInfo *result = 0 ;
18717
18718   arg1 = (Dali::TypeInfo *)jarg1;
18719   arg2 = (Dali::TypeInfo *)jarg2;
18720   if (!arg2) {
18721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18722     return 0;
18723   }
18724   {
18725     try {
18726       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (...) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18738       };
18739     }
18740   }
18741   jresult = (void *)result;
18742   return jresult;
18743 }
18744
18745
18746 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18747   char * jresult ;
18748   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18749   std::string *result = 0 ;
18750
18751   arg1 = (Dali::TypeInfo *)jarg1;
18752   {
18753     try {
18754       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18755     } catch (std::out_of_range& e) {
18756       {
18757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18758       };
18759     } catch (std::exception& e) {
18760       {
18761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (...) {
18764       {
18765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18766       };
18767     }
18768   }
18769   jresult = SWIG_csharp_string_callback(result->c_str());
18770   return jresult;
18771 }
18772
18773
18774 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18775   char * jresult ;
18776   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18777   std::string *result = 0 ;
18778
18779   arg1 = (Dali::TypeInfo *)jarg1;
18780   {
18781     try {
18782       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18783     } catch (std::out_of_range& e) {
18784       {
18785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (std::exception& e) {
18788       {
18789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797   jresult = SWIG_csharp_string_callback(result->c_str());
18798   return jresult;
18799 }
18800
18801
18802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18803   void * jresult ;
18804   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18805   Dali::BaseHandle result;
18806
18807   arg1 = (Dali::TypeInfo *)jarg1;
18808   {
18809     try {
18810       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18811     } catch (std::out_of_range& e) {
18812       {
18813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18814       };
18815     } catch (std::exception& e) {
18816       {
18817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18818       };
18819     } catch (...) {
18820       {
18821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18822       };
18823     }
18824   }
18825   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18826   return jresult;
18827 }
18828
18829
18830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18831   unsigned long jresult ;
18832   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18833   size_t result;
18834
18835   arg1 = (Dali::TypeInfo *)jarg1;
18836   {
18837     try {
18838       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18839     } catch (std::out_of_range& e) {
18840       {
18841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18842       };
18843     } catch (std::exception& e) {
18844       {
18845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18846       };
18847     } catch (...) {
18848       {
18849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18850       };
18851     }
18852   }
18853   jresult = (unsigned long)result;
18854   return jresult;
18855 }
18856
18857
18858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18859   char * jresult ;
18860   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18861   size_t arg2 ;
18862   std::string result;
18863
18864   arg1 = (Dali::TypeInfo *)jarg1;
18865   arg2 = (size_t)jarg2;
18866   {
18867     try {
18868       result = (arg1)->GetActionName(arg2);
18869     } catch (std::out_of_range& e) {
18870       {
18871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18872       };
18873     } catch (std::exception& e) {
18874       {
18875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (...) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18880       };
18881     }
18882   }
18883   jresult = SWIG_csharp_string_callback((&result)->c_str());
18884   return jresult;
18885 }
18886
18887
18888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18889   unsigned long jresult ;
18890   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18891   size_t result;
18892
18893   arg1 = (Dali::TypeInfo *)jarg1;
18894   {
18895     try {
18896       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18897     } catch (std::out_of_range& e) {
18898       {
18899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18900       };
18901     } catch (std::exception& e) {
18902       {
18903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18904       };
18905     } catch (...) {
18906       {
18907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18908       };
18909     }
18910   }
18911   jresult = (unsigned long)result;
18912   return jresult;
18913 }
18914
18915
18916 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18917   char * jresult ;
18918   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18919   size_t arg2 ;
18920   std::string result;
18921
18922   arg1 = (Dali::TypeInfo *)jarg1;
18923   arg2 = (size_t)jarg2;
18924   {
18925     try {
18926       result = (arg1)->GetSignalName(arg2);
18927     } catch (std::out_of_range& e) {
18928       {
18929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18930       };
18931     } catch (std::exception& e) {
18932       {
18933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18934       };
18935     } catch (...) {
18936       {
18937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18938       };
18939     }
18940   }
18941   jresult = SWIG_csharp_string_callback((&result)->c_str());
18942   return jresult;
18943 }
18944
18945
18946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18947   unsigned long jresult ;
18948   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18949   size_t result;
18950
18951   arg1 = (Dali::TypeInfo *)jarg1;
18952   {
18953     try {
18954       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18955     } catch (std::out_of_range& e) {
18956       {
18957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18958       };
18959     } catch (std::exception& e) {
18960       {
18961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18962       };
18963     } catch (...) {
18964       {
18965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18966       };
18967     }
18968   }
18969   jresult = (unsigned long)result;
18970   return jresult;
18971 }
18972
18973
18974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18975   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18976   Dali::Property::IndexContainer *arg2 = 0 ;
18977
18978   arg1 = (Dali::TypeInfo *)jarg1;
18979   arg2 = (Dali::Property::IndexContainer *)jarg2;
18980   if (!arg2) {
18981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18982     return ;
18983   }
18984   {
18985     try {
18986       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18987     } catch (std::out_of_range& e) {
18988       {
18989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18990       };
18991     } catch (std::exception& e) {
18992       {
18993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (...) {
18996       {
18997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18998       };
18999     }
19000   }
19001 }
19002
19003
19004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19005   char * jresult ;
19006   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19007   Dali::Property::Index arg2 ;
19008   std::string *result = 0 ;
19009
19010   arg1 = (Dali::TypeInfo *)jarg1;
19011   arg2 = (Dali::Property::Index)jarg2;
19012   {
19013     try {
19014       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19015     } catch (std::out_of_range& e) {
19016       {
19017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19018       };
19019     } catch (std::exception& e) {
19020       {
19021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19022       };
19023     } catch (...) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19026       };
19027     }
19028   }
19029   jresult = SWIG_csharp_string_callback(result->c_str());
19030   return jresult;
19031 }
19032
19033
19034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19035   void * jresult ;
19036   Dali::TypeRegistry result;
19037
19038   {
19039     try {
19040       result = Dali::TypeRegistry::Get();
19041     } catch (std::out_of_range& e) {
19042       {
19043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19044       };
19045     } catch (std::exception& e) {
19046       {
19047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19052       };
19053     }
19054   }
19055   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19056   return jresult;
19057 }
19058
19059
19060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19061   void * jresult ;
19062   Dali::TypeRegistry *result = 0 ;
19063
19064   {
19065     try {
19066       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19067     } catch (std::out_of_range& e) {
19068       {
19069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19070       };
19071     } catch (std::exception& e) {
19072       {
19073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19078       };
19079     }
19080   }
19081   jresult = (void *)result;
19082   return jresult;
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19087   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19088
19089   arg1 = (Dali::TypeRegistry *)jarg1;
19090   {
19091     try {
19092       delete arg1;
19093     } catch (std::out_of_range& e) {
19094       {
19095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19096       };
19097     } catch (std::exception& e) {
19098       {
19099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (...) {
19102       {
19103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19104       };
19105     }
19106   }
19107 }
19108
19109
19110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19111   void * jresult ;
19112   Dali::TypeRegistry *arg1 = 0 ;
19113   Dali::TypeRegistry *result = 0 ;
19114
19115   arg1 = (Dali::TypeRegistry *)jarg1;
19116   if (!arg1) {
19117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19118     return 0;
19119   }
19120   {
19121     try {
19122       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19123     } catch (std::out_of_range& e) {
19124       {
19125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19126       };
19127     } catch (std::exception& e) {
19128       {
19129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19130       };
19131     } catch (...) {
19132       {
19133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19134       };
19135     }
19136   }
19137   jresult = (void *)result;
19138   return jresult;
19139 }
19140
19141
19142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19143   void * jresult ;
19144   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19145   Dali::TypeRegistry *arg2 = 0 ;
19146   Dali::TypeRegistry *result = 0 ;
19147
19148   arg1 = (Dali::TypeRegistry *)jarg1;
19149   arg2 = (Dali::TypeRegistry *)jarg2;
19150   if (!arg2) {
19151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19152     return 0;
19153   }
19154   {
19155     try {
19156       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19168       };
19169     }
19170   }
19171   jresult = (void *)result;
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19177   void * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   std::string *arg2 = 0 ;
19180   Dali::TypeInfo result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   if (!jarg2) {
19184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19185     return 0;
19186   }
19187   std::string arg2_str(jarg2);
19188   arg2 = &arg2_str;
19189   {
19190     try {
19191       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (...) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19203       };
19204     }
19205   }
19206   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19207
19208   //argout typemap for const std::string&
19209
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19215   void * jresult ;
19216   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19217   std::type_info *arg2 = 0 ;
19218   Dali::TypeInfo result;
19219
19220   arg1 = (Dali::TypeRegistry *)jarg1;
19221   arg2 = (std::type_info *)jarg2;
19222   if (!arg2) {
19223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19224     return 0;
19225   }
19226   {
19227     try {
19228       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19229     } catch (std::out_of_range& e) {
19230       {
19231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (std::exception& e) {
19234       {
19235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19244   return jresult;
19245 }
19246
19247
19248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19249   unsigned long jresult ;
19250   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19251   size_t result;
19252
19253   arg1 = (Dali::TypeRegistry *)jarg1;
19254   {
19255     try {
19256       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (...) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19268       };
19269     }
19270   }
19271   jresult = (unsigned long)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19277   char * jresult ;
19278   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19279   size_t arg2 ;
19280   std::string result;
19281
19282   arg1 = (Dali::TypeRegistry *)jarg1;
19283   arg2 = (size_t)jarg2;
19284   {
19285     try {
19286       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19287     } catch (std::out_of_range& e) {
19288       {
19289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19290       };
19291     } catch (std::exception& e) {
19292       {
19293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (...) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19298       };
19299     }
19300   }
19301   jresult = SWIG_csharp_string_callback((&result)->c_str());
19302   return jresult;
19303 }
19304
19305
19306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19307   void * jresult ;
19308   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19309   Dali::TypeRegistry *result = 0 ;
19310
19311   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19312   {
19313     try {
19314       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329   jresult = (void *)result;
19330   return jresult;
19331 }
19332
19333
19334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19335   void * jresult ;
19336   std::type_info *arg1 = 0 ;
19337   std::type_info *arg2 = 0 ;
19338   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19339   Dali::TypeRegistration *result = 0 ;
19340
19341   arg1 = (std::type_info *)jarg1;
19342   if (!arg1) {
19343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19344     return 0;
19345   }
19346   arg2 = (std::type_info *)jarg2;
19347   if (!arg2) {
19348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19349     return 0;
19350   }
19351   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19352   {
19353     try {
19354       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19355     } catch (std::out_of_range& e) {
19356       {
19357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19358       };
19359     } catch (std::exception& e) {
19360       {
19361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (...) {
19364       {
19365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19366       };
19367     }
19368   }
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19375   void * jresult ;
19376   std::type_info *arg1 = 0 ;
19377   std::type_info *arg2 = 0 ;
19378   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19379   bool arg4 ;
19380   Dali::TypeRegistration *result = 0 ;
19381
19382   arg1 = (std::type_info *)jarg1;
19383   if (!arg1) {
19384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19385     return 0;
19386   }
19387   arg2 = (std::type_info *)jarg2;
19388   if (!arg2) {
19389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19390     return 0;
19391   }
19392   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19393   arg4 = jarg4 ? true : false;
19394   {
19395     try {
19396       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19397     } catch (std::out_of_range& e) {
19398       {
19399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (std::exception& e) {
19402       {
19403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411   jresult = (void *)result;
19412   return jresult;
19413 }
19414
19415
19416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19417   void * jresult ;
19418   std::string *arg1 = 0 ;
19419   std::type_info *arg2 = 0 ;
19420   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19421   Dali::TypeRegistration *result = 0 ;
19422
19423   if (!jarg1) {
19424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19425     return 0;
19426   }
19427   std::string arg1_str(jarg1);
19428   arg1 = &arg1_str;
19429   arg2 = (std::type_info *)jarg2;
19430   if (!arg2) {
19431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19432     return 0;
19433   }
19434   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19435   {
19436     try {
19437       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19438     } catch (std::out_of_range& e) {
19439       {
19440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19441       };
19442     } catch (std::exception& e) {
19443       {
19444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19445       };
19446     } catch (...) {
19447       {
19448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19449       };
19450     }
19451   }
19452   jresult = (void *)result;
19453
19454   //argout typemap for const std::string&
19455
19456   return jresult;
19457 }
19458
19459
19460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19461   char * jresult ;
19462   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19463   std::string result;
19464
19465   arg1 = (Dali::TypeRegistration *)jarg1;
19466   {
19467     try {
19468       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19469     } catch (std::out_of_range& e) {
19470       {
19471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19472       };
19473     } catch (std::exception& e) {
19474       {
19475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19476       };
19477     } catch (...) {
19478       {
19479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19480       };
19481     }
19482   }
19483   jresult = SWIG_csharp_string_callback((&result)->c_str());
19484   return jresult;
19485 }
19486
19487
19488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19489   std::string *arg1 = 0 ;
19490   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19491
19492   if (!jarg1) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19494     return ;
19495   }
19496   std::string arg1_str(jarg1);
19497   arg1 = &arg1_str;
19498   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19499   {
19500     try {
19501       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19502     } catch (std::out_of_range& e) {
19503       {
19504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19505       };
19506     } catch (std::exception& e) {
19507       {
19508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19513       };
19514     }
19515   }
19516
19517   //argout typemap for const std::string&
19518
19519 }
19520
19521
19522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19523   std::string *arg1 = 0 ;
19524   std::string *arg2 = 0 ;
19525   int arg3 ;
19526   Dali::Property::Type arg4 ;
19527   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19528   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19529
19530   if (!jarg1) {
19531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19532     return ;
19533   }
19534   std::string arg1_str(jarg1);
19535   arg1 = &arg1_str;
19536   if (!jarg2) {
19537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19538     return ;
19539   }
19540   std::string arg2_str(jarg2);
19541   arg2 = &arg2_str;
19542   arg3 = (int)jarg3;
19543   arg4 = (Dali::Property::Type)jarg4;
19544   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19545   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19546   {
19547     try {
19548       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19549     } catch (std::out_of_range& e) {
19550       {
19551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19552       };
19553     } catch (std::exception& e) {
19554       {
19555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19556       };
19557     } catch (...) {
19558       {
19559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19560       };
19561     }
19562   }
19563
19564   //argout typemap for const std::string&
19565
19566
19567   //argout typemap for const std::string&
19568
19569 }
19570
19571
19572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19573   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19574
19575   arg1 = (Dali::TypeRegistration *)jarg1;
19576   {
19577     try {
19578       delete arg1;
19579     } catch (std::out_of_range& e) {
19580       {
19581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19582       };
19583     } catch (std::exception& e) {
19584       {
19585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19586       };
19587     } catch (...) {
19588       {
19589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19590       };
19591     }
19592   }
19593 }
19594
19595
19596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19597   void * jresult ;
19598   Dali::TypeRegistration *arg1 = 0 ;
19599   std::string *arg2 = 0 ;
19600   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19601   Dali::SignalConnectorType *result = 0 ;
19602
19603   arg1 = (Dali::TypeRegistration *)jarg1;
19604   if (!arg1) {
19605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19606     return 0;
19607   }
19608   if (!jarg2) {
19609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19610     return 0;
19611   }
19612   std::string arg2_str(jarg2);
19613   arg2 = &arg2_str;
19614   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19615   {
19616     try {
19617       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19618     } catch (std::out_of_range& e) {
19619       {
19620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19621       };
19622     } catch (std::exception& e) {
19623       {
19624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (...) {
19627       {
19628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19629       };
19630     }
19631   }
19632   jresult = (void *)result;
19633
19634   //argout typemap for const std::string&
19635
19636   return jresult;
19637 }
19638
19639
19640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19641   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19642
19643   arg1 = (Dali::SignalConnectorType *)jarg1;
19644   {
19645     try {
19646       delete arg1;
19647     } catch (std::out_of_range& e) {
19648       {
19649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19650       };
19651     } catch (std::exception& e) {
19652       {
19653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19658       };
19659     }
19660   }
19661 }
19662
19663
19664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19665   void * jresult ;
19666   Dali::TypeRegistration *arg1 = 0 ;
19667   std::string *arg2 = 0 ;
19668   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19669   Dali::TypeAction *result = 0 ;
19670
19671   arg1 = (Dali::TypeRegistration *)jarg1;
19672   if (!arg1) {
19673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19674     return 0;
19675   }
19676   if (!jarg2) {
19677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19678     return 0;
19679   }
19680   std::string arg2_str(jarg2);
19681   arg2 = &arg2_str;
19682   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19683   {
19684     try {
19685       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19686     } catch (std::out_of_range& e) {
19687       {
19688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19689       };
19690     } catch (std::exception& e) {
19691       {
19692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19693       };
19694     } catch (...) {
19695       {
19696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19697       };
19698     }
19699   }
19700   jresult = (void *)result;
19701
19702   //argout typemap for const std::string&
19703
19704   return jresult;
19705 }
19706
19707
19708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19709   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19710
19711   arg1 = (Dali::TypeAction *)jarg1;
19712   {
19713     try {
19714       delete arg1;
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19726       };
19727     }
19728   }
19729 }
19730
19731
19732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19733   void * jresult ;
19734   Dali::TypeRegistration *arg1 = 0 ;
19735   std::string *arg2 = 0 ;
19736   Dali::Property::Index arg3 ;
19737   Dali::Property::Type arg4 ;
19738   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19739   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19740   Dali::PropertyRegistration *result = 0 ;
19741
19742   arg1 = (Dali::TypeRegistration *)jarg1;
19743   if (!arg1) {
19744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19745     return 0;
19746   }
19747   if (!jarg2) {
19748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19749     return 0;
19750   }
19751   std::string arg2_str(jarg2);
19752   arg2 = &arg2_str;
19753   arg3 = (Dali::Property::Index)jarg3;
19754   arg4 = (Dali::Property::Type)jarg4;
19755   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19756   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19757   {
19758     try {
19759       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (...) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19771       };
19772     }
19773   }
19774   jresult = (void *)result;
19775
19776   //argout typemap for const std::string&
19777
19778   return jresult;
19779 }
19780
19781
19782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19783   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19784
19785   arg1 = (Dali::PropertyRegistration *)jarg1;
19786   {
19787     try {
19788       delete arg1;
19789     } catch (std::out_of_range& e) {
19790       {
19791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19792       };
19793     } catch (std::exception& e) {
19794       {
19795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19796       };
19797     } catch (...) {
19798       {
19799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19800       };
19801     }
19802   }
19803 }
19804
19805
19806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19807   void * jresult ;
19808   Dali::TypeRegistration *arg1 = 0 ;
19809   std::string *arg2 = 0 ;
19810   Dali::Property::Index arg3 ;
19811   Dali::Property::Type arg4 ;
19812   Dali::AnimatablePropertyRegistration *result = 0 ;
19813
19814   arg1 = (Dali::TypeRegistration *)jarg1;
19815   if (!arg1) {
19816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19817     return 0;
19818   }
19819   if (!jarg2) {
19820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19821     return 0;
19822   }
19823   std::string arg2_str(jarg2);
19824   arg2 = &arg2_str;
19825   arg3 = (Dali::Property::Index)jarg3;
19826   arg4 = (Dali::Property::Type)jarg4;
19827   {
19828     try {
19829       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19830     } catch (std::out_of_range& e) {
19831       {
19832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (std::exception& e) {
19835       {
19836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (...) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19841       };
19842     }
19843   }
19844   jresult = (void *)result;
19845
19846   //argout typemap for const std::string&
19847
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19853   void * jresult ;
19854   Dali::TypeRegistration *arg1 = 0 ;
19855   std::string *arg2 = 0 ;
19856   Dali::Property::Index arg3 ;
19857   Dali::Property::Value *arg4 = 0 ;
19858   Dali::AnimatablePropertyRegistration *result = 0 ;
19859
19860   arg1 = (Dali::TypeRegistration *)jarg1;
19861   if (!arg1) {
19862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19863     return 0;
19864   }
19865   if (!jarg2) {
19866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19867     return 0;
19868   }
19869   std::string arg2_str(jarg2);
19870   arg2 = &arg2_str;
19871   arg3 = (Dali::Property::Index)jarg3;
19872   arg4 = (Dali::Property::Value *)jarg4;
19873   if (!arg4) {
19874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19875     return 0;
19876   }
19877   {
19878     try {
19879       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19887       };
19888     } catch (...) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19891       };
19892     }
19893   }
19894   jresult = (void *)result;
19895
19896   //argout typemap for const std::string&
19897
19898   return jresult;
19899 }
19900
19901
19902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19903   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19904
19905   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19906   {
19907     try {
19908       delete arg1;
19909     } catch (std::out_of_range& e) {
19910       {
19911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19912       };
19913     } catch (std::exception& e) {
19914       {
19915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19916       };
19917     } catch (...) {
19918       {
19919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19920       };
19921     }
19922   }
19923 }
19924
19925
19926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19927   void * jresult ;
19928   Dali::TypeRegistration *arg1 = 0 ;
19929   std::string *arg2 = 0 ;
19930   Dali::Property::Index arg3 ;
19931   Dali::Property::Index arg4 ;
19932   unsigned int arg5 ;
19933   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19934
19935   arg1 = (Dali::TypeRegistration *)jarg1;
19936   if (!arg1) {
19937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19938     return 0;
19939   }
19940   if (!jarg2) {
19941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19942     return 0;
19943   }
19944   std::string arg2_str(jarg2);
19945   arg2 = &arg2_str;
19946   arg3 = (Dali::Property::Index)jarg3;
19947   arg4 = (Dali::Property::Index)jarg4;
19948   arg5 = (unsigned int)jarg5;
19949   {
19950     try {
19951       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (...) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19963       };
19964     }
19965   }
19966   jresult = (void *)result;
19967
19968   //argout typemap for const std::string&
19969
19970   return jresult;
19971 }
19972
19973
19974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19975   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19976
19977   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19978   {
19979     try {
19980       delete arg1;
19981     } catch (std::out_of_range& e) {
19982       {
19983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19984       };
19985     } catch (std::exception& e) {
19986       {
19987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19988       };
19989     } catch (...) {
19990       {
19991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19992       };
19993     }
19994   }
19995 }
19996
19997
19998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19999   void * jresult ;
20000   Dali::TypeRegistration *arg1 = 0 ;
20001   std::string *arg2 = 0 ;
20002   Dali::Property::Index arg3 ;
20003   Dali::Property::Type arg4 ;
20004   Dali::ChildPropertyRegistration *result = 0 ;
20005
20006   arg1 = (Dali::TypeRegistration *)jarg1;
20007   if (!arg1) {
20008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20009     return 0;
20010   }
20011   if (!jarg2) {
20012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20013     return 0;
20014   }
20015   std::string arg2_str(jarg2);
20016   arg2 = &arg2_str;
20017   arg3 = (Dali::Property::Index)jarg3;
20018   arg4 = (Dali::Property::Type)jarg4;
20019   {
20020     try {
20021       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20022     } catch (std::out_of_range& e) {
20023       {
20024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20025       };
20026     } catch (std::exception& e) {
20027       {
20028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (...) {
20031       {
20032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20033       };
20034     }
20035   }
20036   jresult = (void *)result;
20037
20038   //argout typemap for const std::string&
20039
20040   return jresult;
20041 }
20042
20043
20044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20045   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20046
20047   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20048   {
20049     try {
20050       delete arg1;
20051     } catch (std::out_of_range& e) {
20052       {
20053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20054       };
20055     } catch (std::exception& e) {
20056       {
20057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20058       };
20059     } catch (...) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20062       };
20063     }
20064   }
20065 }
20066
20067
20068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20069   unsigned int jresult ;
20070   std::string *arg1 = 0 ;
20071   std::type_info *arg2 = 0 ;
20072   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20073   bool result;
20074
20075   if (!jarg1) {
20076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20077     return 0;
20078   }
20079   std::string arg1_str(jarg1);
20080   arg1 = &arg1_str;
20081   arg2 = (std::type_info *)jarg2;
20082   if (!arg2) {
20083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20084     return 0;
20085   }
20086   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20087   {
20088     try {
20089       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20090     } catch (std::out_of_range& e) {
20091       {
20092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20093       };
20094     } catch (std::exception& e) {
20095       {
20096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (...) {
20099       {
20100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20101       };
20102     }
20103   }
20104   jresult = result;
20105
20106   //argout typemap for const std::string&
20107
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20113   unsigned int jresult ;
20114   std::string *arg1 = 0 ;
20115   std::string *arg2 = 0 ;
20116   Dali::Property::Index arg3 ;
20117   Dali::Property::Type arg4 ;
20118   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20119   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20120   bool result;
20121
20122   if (!jarg1) {
20123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20124     return 0;
20125   }
20126   std::string arg1_str(jarg1);
20127   arg1 = &arg1_str;
20128   if (!jarg2) {
20129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20130     return 0;
20131   }
20132   std::string arg2_str(jarg2);
20133   arg2 = &arg2_str;
20134   arg3 = (Dali::Property::Index)jarg3;
20135   arg4 = (Dali::Property::Type)jarg4;
20136   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20137   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20138   {
20139     try {
20140       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20148       };
20149     } catch (...) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20152       };
20153     }
20154   }
20155   jresult = result;
20156
20157   //argout typemap for const std::string&
20158
20159
20160   //argout typemap for const std::string&
20161
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20167   float jresult ;
20168   float result;
20169
20170   result = (float)(float)Dali::ParentOrigin::TOP;
20171   jresult = result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20177   float jresult ;
20178   float result;
20179
20180   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20187   float jresult ;
20188   float result;
20189
20190   result = (float)(float)Dali::ParentOrigin::LEFT;
20191   jresult = result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20197   float jresult ;
20198   float result;
20199
20200   result = (float)(float)Dali::ParentOrigin::RIGHT;
20201   jresult = result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20207   float jresult ;
20208   float result;
20209
20210   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20217   void * jresult ;
20218   Dali::Vector3 *result = 0 ;
20219
20220   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20227   void * jresult ;
20228   Dali::Vector3 *result = 0 ;
20229
20230   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20237   void * jresult ;
20238   Dali::Vector3 *result = 0 ;
20239
20240   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20247   void * jresult ;
20248   Dali::Vector3 *result = 0 ;
20249
20250   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20287   void * jresult ;
20288   Dali::Vector3 *result = 0 ;
20289
20290   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20291   jresult = (void *)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20297   void * jresult ;
20298   Dali::Vector3 *result = 0 ;
20299
20300   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20301   jresult = (void *)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20307   float jresult ;
20308   float result;
20309
20310   result = (float)(float)Dali::AnchorPoint::TOP;
20311   jresult = result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20317   float jresult ;
20318   float result;
20319
20320   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20327   float jresult ;
20328   float result;
20329
20330   result = (float)(float)Dali::AnchorPoint::LEFT;
20331   jresult = result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20337   float jresult ;
20338   float result;
20339
20340   result = (float)(float)Dali::AnchorPoint::RIGHT;
20341   jresult = result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20347   float jresult ;
20348   float result;
20349
20350   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20351   jresult = result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20357   void * jresult ;
20358   Dali::Vector3 *result = 0 ;
20359
20360   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20367   void * jresult ;
20368   Dali::Vector3 *result = 0 ;
20369
20370   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20377   void * jresult ;
20378   Dali::Vector3 *result = 0 ;
20379
20380   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20387   void * jresult ;
20388   Dali::Vector3 *result = 0 ;
20389
20390   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20397   void * jresult ;
20398   Dali::Vector3 *result = 0 ;
20399
20400   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20407   void * jresult ;
20408   Dali::Vector3 *result = 0 ;
20409
20410   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20417   void * jresult ;
20418   Dali::Vector3 *result = 0 ;
20419
20420   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20427   void * jresult ;
20428   Dali::Vector3 *result = 0 ;
20429
20430   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20437   void * jresult ;
20438   Dali::Vector3 *result = 0 ;
20439
20440   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20447   void * jresult ;
20448   Dali::Vector4 *result = 0 ;
20449
20450   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20457   void * jresult ;
20458   Dali::Vector4 *result = 0 ;
20459
20460   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20461   jresult = (void *)result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20467   void * jresult ;
20468   Dali::Vector4 *result = 0 ;
20469
20470   result = (Dali::Vector4 *)&Dali::Color::RED;
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20477   void * jresult ;
20478   Dali::Vector4 *result = 0 ;
20479
20480   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20481   jresult = (void *)result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20487   void * jresult ;
20488   Dali::Vector4 *result = 0 ;
20489
20490   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20491   jresult = (void *)result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20497   void * jresult ;
20498   Dali::Vector4 *result = 0 ;
20499
20500   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20501   jresult = (void *)result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20507   void * jresult ;
20508   Dali::Vector4 *result = 0 ;
20509
20510   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20511   jresult = (void *)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20517   void * jresult ;
20518   Dali::Vector4 *result = 0 ;
20519
20520   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20521   jresult = (void *)result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20527   void * jresult ;
20528   Dali::Vector4 *result = 0 ;
20529
20530   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20531   jresult = (void *)result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20547   float jresult ;
20548   float result;
20549
20550   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20557   float jresult ;
20558   float result;
20559
20560   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20561   jresult = result;
20562   return jresult;
20563 }
20564
20565
20566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20567   float jresult ;
20568   float result;
20569
20570   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20577   float jresult ;
20578   float result;
20579
20580   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20581   jresult = result;
20582   return jresult;
20583 }
20584
20585
20586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20587   float jresult ;
20588   float result;
20589
20590   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20591   jresult = result;
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20597   float jresult ;
20598   float result;
20599
20600   result = (float)(float)Dali::Math::PI;
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20607   float jresult ;
20608   float result;
20609
20610   result = (float)(float)Dali::Math::PI_2;
20611   jresult = result;
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20617   float jresult ;
20618   float result;
20619
20620   result = (float)(float)Dali::Math::PI_4;
20621   jresult = result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20627   float jresult ;
20628   float result;
20629
20630   result = (float)(float)Dali::Math::PI_OVER_180;
20631   jresult = result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20637   float jresult ;
20638   float result;
20639
20640   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20641   jresult = result;
20642   return jresult;
20643 }
20644
20645
20646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20647   int jresult ;
20648   Dali::ResizePolicy::Type result;
20649
20650   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20651   jresult = (int)result;
20652   return jresult;
20653 }
20654
20655
20656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20657   unsigned long jresult ;
20658   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20659   Dali::VectorBase::SizeType result;
20660
20661   arg1 = (Dali::VectorBase *)jarg1;
20662   {
20663     try {
20664       result = ((Dali::VectorBase const *)arg1)->Count();
20665     } catch (std::out_of_range& e) {
20666       {
20667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (std::exception& e) {
20670       {
20671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679   jresult = (unsigned long)result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20685   unsigned long jresult ;
20686   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20687   Dali::VectorBase::SizeType result;
20688
20689   arg1 = (Dali::VectorBase *)jarg1;
20690   {
20691     try {
20692       result = ((Dali::VectorBase const *)arg1)->Size();
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (...) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20704       };
20705     }
20706   }
20707   jresult = (unsigned long)result;
20708   return jresult;
20709 }
20710
20711
20712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20713   unsigned int jresult ;
20714   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20715   bool result;
20716
20717   arg1 = (Dali::VectorBase *)jarg1;
20718   {
20719     try {
20720       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20721     } catch (std::out_of_range& e) {
20722       {
20723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20724       };
20725     } catch (std::exception& e) {
20726       {
20727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20728       };
20729     } catch (...) {
20730       {
20731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20732       };
20733     }
20734   }
20735   jresult = result;
20736   return jresult;
20737 }
20738
20739
20740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20741   unsigned long jresult ;
20742   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20743   Dali::VectorBase::SizeType result;
20744
20745   arg1 = (Dali::VectorBase *)jarg1;
20746   {
20747     try {
20748       result = ((Dali::VectorBase const *)arg1)->Capacity();
20749     } catch (std::out_of_range& e) {
20750       {
20751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20752       };
20753     } catch (std::exception& e) {
20754       {
20755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20756       };
20757     } catch (...) {
20758       {
20759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20760       };
20761     }
20762   }
20763   jresult = (unsigned long)result;
20764   return jresult;
20765 }
20766
20767
20768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20769   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20770
20771   arg1 = (Dali::VectorBase *)jarg1;
20772   {
20773     try {
20774       (arg1)->Release();
20775     } catch (std::out_of_range& e) {
20776       {
20777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20778       };
20779     } catch (std::exception& e) {
20780       {
20781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20786       };
20787     }
20788   }
20789 }
20790
20791
20792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20793   void * jresult ;
20794   Dali::Image *result = 0 ;
20795
20796   {
20797     try {
20798       result = (Dali::Image *)new Dali::Image();
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (...) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20810       };
20811     }
20812   }
20813   jresult = (void *)result;
20814   return jresult;
20815 }
20816
20817
20818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20819   Dali::Image *arg1 = (Dali::Image *) 0 ;
20820
20821   arg1 = (Dali::Image *)jarg1;
20822   {
20823     try {
20824       delete arg1;
20825     } catch (std::out_of_range& e) {
20826       {
20827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20828       };
20829     } catch (std::exception& e) {
20830       {
20831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20832       };
20833     } catch (...) {
20834       {
20835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20836       };
20837     }
20838   }
20839 }
20840
20841
20842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20843   void * jresult ;
20844   Dali::Image *arg1 = 0 ;
20845   Dali::Image *result = 0 ;
20846
20847   arg1 = (Dali::Image *)jarg1;
20848   if (!arg1) {
20849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20850     return 0;
20851   }
20852   {
20853     try {
20854       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20855     } catch (std::out_of_range& e) {
20856       {
20857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (std::exception& e) {
20860       {
20861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20862       };
20863     } catch (...) {
20864       {
20865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20866       };
20867     }
20868   }
20869   jresult = (void *)result;
20870   return jresult;
20871 }
20872
20873
20874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20875   void * jresult ;
20876   Dali::Image *arg1 = (Dali::Image *) 0 ;
20877   Dali::Image *arg2 = 0 ;
20878   Dali::Image *result = 0 ;
20879
20880   arg1 = (Dali::Image *)jarg1;
20881   arg2 = (Dali::Image *)jarg2;
20882   if (!arg2) {
20883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20884     return 0;
20885   }
20886   {
20887     try {
20888       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20889     } catch (std::out_of_range& e) {
20890       {
20891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20892       };
20893     } catch (std::exception& e) {
20894       {
20895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20896       };
20897     } catch (...) {
20898       {
20899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20900       };
20901     }
20902   }
20903   jresult = (void *)result;
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20909   void * jresult ;
20910   Dali::BaseHandle arg1 ;
20911   Dali::BaseHandle *argp1 ;
20912   Dali::Image result;
20913
20914   argp1 = (Dali::BaseHandle *)jarg1;
20915   if (!argp1) {
20916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20917     return 0;
20918   }
20919   arg1 = *argp1;
20920   {
20921     try {
20922       result = Dali::Image::DownCast(arg1);
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937   jresult = new Dali::Image((const Dali::Image &)result);
20938   return jresult;
20939 }
20940
20941
20942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20943   unsigned int jresult ;
20944   Dali::Image *arg1 = (Dali::Image *) 0 ;
20945   unsigned int result;
20946
20947   arg1 = (Dali::Image *)jarg1;
20948   {
20949     try {
20950       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20951     } catch (std::out_of_range& e) {
20952       {
20953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20954       };
20955     } catch (std::exception& e) {
20956       {
20957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (...) {
20960       {
20961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20962       };
20963     }
20964   }
20965   jresult = result;
20966   return jresult;
20967 }
20968
20969
20970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20971   unsigned int jresult ;
20972   Dali::Image *arg1 = (Dali::Image *) 0 ;
20973   unsigned int result;
20974
20975   arg1 = (Dali::Image *)jarg1;
20976   {
20977     try {
20978       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20979     } catch (std::out_of_range& e) {
20980       {
20981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20982       };
20983     } catch (std::exception& e) {
20984       {
20985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (...) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20990       };
20991     }
20992   }
20993   jresult = result;
20994   return jresult;
20995 }
20996
20997
20998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20999   void * jresult ;
21000   Dali::Image *arg1 = (Dali::Image *) 0 ;
21001   Dali::Image::ImageSignalType *result = 0 ;
21002
21003   arg1 = (Dali::Image *)jarg1;
21004   {
21005     try {
21006       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21007     } catch (std::out_of_range& e) {
21008       {
21009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (std::exception& e) {
21012       {
21013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (...) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21018       };
21019     }
21020   }
21021   jresult = (void *)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21027   int jresult ;
21028   Dali::Pixel::Format result;
21029
21030   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21031   jresult = (int)result;
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21037   int jresult ;
21038   Dali::Pixel::Format result;
21039
21040   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21041   jresult = (int)result;
21042   return jresult;
21043 }
21044
21045
21046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21047   unsigned int jresult ;
21048   Dali::Pixel::Format arg1 ;
21049   bool result;
21050
21051   arg1 = (Dali::Pixel::Format)jarg1;
21052   {
21053     try {
21054       result = (bool)Dali::Pixel::HasAlpha(arg1);
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (...) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21066       };
21067     }
21068   }
21069   jresult = result;
21070   return jresult;
21071 }
21072
21073
21074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21075   unsigned int jresult ;
21076   Dali::Pixel::Format arg1 ;
21077   unsigned int result;
21078
21079   arg1 = (Dali::Pixel::Format)jarg1;
21080   {
21081     try {
21082       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21094       };
21095     }
21096   }
21097   jresult = result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21103   Dali::Pixel::Format arg1 ;
21104   int *arg2 = 0 ;
21105   int *arg3 = 0 ;
21106
21107   arg1 = (Dali::Pixel::Format)jarg1;
21108   arg2 = (int *)jarg2;
21109   if (!arg2) {
21110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21111     return ;
21112   }
21113   arg3 = (int *)jarg3;
21114   if (!arg3) {
21115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21116     return ;
21117   }
21118   {
21119     try {
21120       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21121     } catch (std::out_of_range& e) {
21122       {
21123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21124       };
21125     } catch (std::exception& e) {
21126       {
21127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21128       };
21129     } catch (...) {
21130       {
21131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21132       };
21133     }
21134   }
21135 }
21136
21137
21138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21139   void * jresult ;
21140   unsigned char *arg1 = (unsigned char *) 0 ;
21141   unsigned int arg2 ;
21142   unsigned int arg3 ;
21143   unsigned int arg4 ;
21144   Dali::Pixel::Format arg5 ;
21145   Dali::PixelData::ReleaseFunction arg6 ;
21146   Dali::PixelData result;
21147
21148   arg1 = jarg1;
21149   arg2 = (unsigned int)jarg2;
21150   arg3 = (unsigned int)jarg3;
21151   arg4 = (unsigned int)jarg4;
21152   arg5 = (Dali::Pixel::Format)jarg5;
21153   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21154   {
21155     try {
21156       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21157     } catch (std::out_of_range& e) {
21158       {
21159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21160       };
21161     } catch (std::exception& e) {
21162       {
21163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21168       };
21169     }
21170   }
21171   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21172
21173
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21179   void * jresult ;
21180   Dali::PixelData *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::PixelData *)new Dali::PixelData();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (...) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21196       };
21197     }
21198   }
21199   jresult = (void *)result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21205   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21206
21207   arg1 = (Dali::PixelData *)jarg1;
21208   {
21209     try {
21210       delete arg1;
21211     } catch (std::out_of_range& e) {
21212       {
21213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21214       };
21215     } catch (std::exception& e) {
21216       {
21217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (...) {
21220       {
21221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21222       };
21223     }
21224   }
21225 }
21226
21227
21228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21229   void * jresult ;
21230   Dali::PixelData *arg1 = 0 ;
21231   Dali::PixelData *result = 0 ;
21232
21233   arg1 = (Dali::PixelData *)jarg1;
21234   if (!arg1) {
21235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21236     return 0;
21237   }
21238   {
21239     try {
21240       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21241     } catch (std::out_of_range& e) {
21242       {
21243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21244       };
21245     } catch (std::exception& e) {
21246       {
21247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21248       };
21249     } catch (...) {
21250       {
21251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21252       };
21253     }
21254   }
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21261   void * jresult ;
21262   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21263   Dali::PixelData *arg2 = 0 ;
21264   Dali::PixelData *result = 0 ;
21265
21266   arg1 = (Dali::PixelData *)jarg1;
21267   arg2 = (Dali::PixelData *)jarg2;
21268   if (!arg2) {
21269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21270     return 0;
21271   }
21272   {
21273     try {
21274       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21275     } catch (std::out_of_range& e) {
21276       {
21277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (std::exception& e) {
21280       {
21281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289   jresult = (void *)result;
21290   return jresult;
21291 }
21292
21293
21294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21295   unsigned int jresult ;
21296   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21297   unsigned int result;
21298
21299   arg1 = (Dali::PixelData *)jarg1;
21300   {
21301     try {
21302       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21303     } catch (std::out_of_range& e) {
21304       {
21305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21306       };
21307     } catch (std::exception& e) {
21308       {
21309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21310       };
21311     } catch (...) {
21312       {
21313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21314       };
21315     }
21316   }
21317   jresult = result;
21318   return jresult;
21319 }
21320
21321
21322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21323   unsigned int jresult ;
21324   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21325   unsigned int result;
21326
21327   arg1 = (Dali::PixelData *)jarg1;
21328   {
21329     try {
21330       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21331     } catch (std::out_of_range& e) {
21332       {
21333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21334       };
21335     } catch (std::exception& e) {
21336       {
21337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21338       };
21339     } catch (...) {
21340       {
21341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21342       };
21343     }
21344   }
21345   jresult = result;
21346   return jresult;
21347 }
21348
21349
21350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21351   int jresult ;
21352   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21353   Dali::Pixel::Format result;
21354
21355   arg1 = (Dali::PixelData *)jarg1;
21356   {
21357     try {
21358       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21359     } catch (std::out_of_range& e) {
21360       {
21361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (std::exception& e) {
21364       {
21365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21366       };
21367     } catch (...) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21370       };
21371     }
21372   }
21373   jresult = (int)result;
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21379   unsigned int jresult ;
21380   unsigned int result;
21381
21382   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21389   unsigned int jresult ;
21390   unsigned int result;
21391
21392   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21393   jresult = result;
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21399   unsigned int jresult ;
21400   unsigned int result;
21401
21402   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21403   jresult = result;
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21409   unsigned int jresult ;
21410   unsigned int result;
21411
21412   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21413   jresult = result;
21414   return jresult;
21415 }
21416
21417
21418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21419   unsigned int jresult ;
21420   unsigned int result;
21421
21422   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21423   jresult = result;
21424   return jresult;
21425 }
21426
21427
21428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21429   unsigned int jresult ;
21430   unsigned int result;
21431
21432   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21433   jresult = result;
21434   return jresult;
21435 }
21436
21437
21438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21439   void * jresult ;
21440   Dali::TextureType::Type arg1 ;
21441   Dali::Pixel::Format arg2 ;
21442   unsigned int arg3 ;
21443   unsigned int arg4 ;
21444   Dali::Texture result;
21445
21446   arg1 = (Dali::TextureType::Type)jarg1;
21447   arg2 = (Dali::Pixel::Format)jarg2;
21448   arg3 = (unsigned int)jarg3;
21449   arg4 = (unsigned int)jarg4;
21450   {
21451     try {
21452       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21464       };
21465     }
21466   }
21467   jresult = new Dali::Texture((const Dali::Texture &)result);
21468   return jresult;
21469 }
21470
21471
21472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21473   void * jresult ;
21474   NativeImageInterface *arg1 = 0 ;
21475   Dali::Texture result;
21476
21477   arg1 = (NativeImageInterface *)jarg1;
21478   if (!arg1) {
21479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21480     return 0;
21481   }
21482   {
21483     try {
21484       result = Dali::Texture::New(*arg1);
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (...) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21496       };
21497     }
21498   }
21499   jresult = new Dali::Texture((const Dali::Texture &)result);
21500   return jresult;
21501 }
21502
21503
21504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21505   void * jresult ;
21506   Dali::Texture *result = 0 ;
21507
21508   {
21509     try {
21510       result = (Dali::Texture *)new Dali::Texture();
21511     } catch (std::out_of_range& e) {
21512       {
21513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (std::exception& e) {
21516       {
21517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21518       };
21519     } catch (...) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21522       };
21523     }
21524   }
21525   jresult = (void *)result;
21526   return jresult;
21527 }
21528
21529
21530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21531   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21532
21533   arg1 = (Dali::Texture *)jarg1;
21534   {
21535     try {
21536       delete arg1;
21537     } catch (std::out_of_range& e) {
21538       {
21539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21540       };
21541     } catch (std::exception& e) {
21542       {
21543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21544       };
21545     } catch (...) {
21546       {
21547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21548       };
21549     }
21550   }
21551 }
21552
21553
21554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21555   void * jresult ;
21556   Dali::Texture *arg1 = 0 ;
21557   Dali::Texture *result = 0 ;
21558
21559   arg1 = (Dali::Texture *)jarg1;
21560   if (!arg1) {
21561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21562     return 0;
21563   }
21564   {
21565     try {
21566       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21567     } catch (std::out_of_range& e) {
21568       {
21569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21570       };
21571     } catch (std::exception& e) {
21572       {
21573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (...) {
21576       {
21577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21578       };
21579     }
21580   }
21581   jresult = (void *)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21587   void * jresult ;
21588   Dali::BaseHandle arg1 ;
21589   Dali::BaseHandle *argp1 ;
21590   Dali::Texture result;
21591
21592   argp1 = (Dali::BaseHandle *)jarg1;
21593   if (!argp1) {
21594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21595     return 0;
21596   }
21597   arg1 = *argp1;
21598   {
21599     try {
21600       result = Dali::Texture::DownCast(arg1);
21601     } catch (std::out_of_range& e) {
21602       {
21603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (std::exception& e) {
21606       {
21607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21608       };
21609     } catch (...) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21612       };
21613     }
21614   }
21615   jresult = new Dali::Texture((const Dali::Texture &)result);
21616   return jresult;
21617 }
21618
21619
21620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21621   void * jresult ;
21622   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21623   Dali::Texture *arg2 = 0 ;
21624   Dali::Texture *result = 0 ;
21625
21626   arg1 = (Dali::Texture *)jarg1;
21627   arg2 = (Dali::Texture *)jarg2;
21628   if (!arg2) {
21629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21630     return 0;
21631   }
21632   {
21633     try {
21634       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21635     } catch (std::out_of_range& e) {
21636       {
21637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21638       };
21639     } catch (std::exception& e) {
21640       {
21641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21642       };
21643     } catch (...) {
21644       {
21645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21646       };
21647     }
21648   }
21649   jresult = (void *)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21655   unsigned int jresult ;
21656   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21657   Dali::PixelData arg2 ;
21658   Dali::PixelData *argp2 ;
21659   bool result;
21660
21661   arg1 = (Dali::Texture *)jarg1;
21662   argp2 = (Dali::PixelData *)jarg2;
21663   if (!argp2) {
21664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21665     return 0;
21666   }
21667   arg2 = *argp2;
21668   {
21669     try {
21670       result = (bool)(arg1)->Upload(arg2);
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21682       };
21683     }
21684   }
21685   jresult = result;
21686   return jresult;
21687 }
21688
21689
21690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
21691   unsigned int jresult ;
21692   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21693   Dali::PixelData arg2 ;
21694   unsigned int arg3 ;
21695   unsigned int arg4 ;
21696   unsigned int arg5 ;
21697   unsigned int arg6 ;
21698   unsigned int arg7 ;
21699   unsigned int arg8 ;
21700   Dali::PixelData *argp2 ;
21701   bool result;
21702
21703   arg1 = (Dali::Texture *)jarg1;
21704   argp2 = (Dali::PixelData *)jarg2;
21705   if (!argp2) {
21706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21707     return 0;
21708   }
21709   arg2 = *argp2;
21710   arg3 = (unsigned int)jarg3;
21711   arg4 = (unsigned int)jarg4;
21712   arg5 = (unsigned int)jarg5;
21713   arg6 = (unsigned int)jarg6;
21714   arg7 = (unsigned int)jarg7;
21715   arg8 = (unsigned int)jarg8;
21716   {
21717     try {
21718       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21726       };
21727     } catch (...) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21730       };
21731     }
21732   }
21733   jresult = result;
21734   return jresult;
21735 }
21736
21737
21738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21739   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21740
21741   arg1 = (Dali::Texture *)jarg1;
21742   {
21743     try {
21744       (arg1)->GenerateMipmaps();
21745     } catch (std::out_of_range& e) {
21746       {
21747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21748       };
21749     } catch (std::exception& e) {
21750       {
21751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21756       };
21757     }
21758   }
21759 }
21760
21761
21762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21763   unsigned int jresult ;
21764   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21765   unsigned int result;
21766
21767   arg1 = (Dali::Texture *)jarg1;
21768   {
21769     try {
21770       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21771     } catch (std::out_of_range& e) {
21772       {
21773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (std::exception& e) {
21776       {
21777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (...) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21782       };
21783     }
21784   }
21785   jresult = result;
21786   return jresult;
21787 }
21788
21789
21790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21791   unsigned int jresult ;
21792   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21793   unsigned int result;
21794
21795   arg1 = (Dali::Texture *)jarg1;
21796   {
21797     try {
21798       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21799     } catch (std::out_of_range& e) {
21800       {
21801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (std::exception& e) {
21804       {
21805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813   jresult = result;
21814   return jresult;
21815 }
21816
21817
21818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21819   void * jresult ;
21820   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21821   Dali::Texture *result = 0 ;
21822
21823   arg1 = (Dali::Internal::Texture *)jarg1;
21824   {
21825     try {
21826       result = (Dali::Texture *)new Dali::Texture(arg1);
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (...) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21838       };
21839     }
21840   }
21841   jresult = (void *)result;
21842   return jresult;
21843 }
21844
21845
21846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21847   void * jresult ;
21848   Dali::Sampler result;
21849
21850   {
21851     try {
21852       result = Dali::Sampler::New();
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21868   return jresult;
21869 }
21870
21871
21872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21873   void * jresult ;
21874   Dali::Sampler *result = 0 ;
21875
21876   {
21877     try {
21878       result = (Dali::Sampler *)new Dali::Sampler();
21879     } catch (std::out_of_range& e) {
21880       {
21881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (std::exception& e) {
21884       {
21885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893   jresult = (void *)result;
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21899   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21900
21901   arg1 = (Dali::Sampler *)jarg1;
21902   {
21903     try {
21904       delete arg1;
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21912       };
21913     } catch (...) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21916       };
21917     }
21918   }
21919 }
21920
21921
21922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21923   void * jresult ;
21924   Dali::Sampler *arg1 = 0 ;
21925   Dali::Sampler *result = 0 ;
21926
21927   arg1 = (Dali::Sampler *)jarg1;
21928   if (!arg1) {
21929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21930     return 0;
21931   }
21932   {
21933     try {
21934       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21935     } catch (std::out_of_range& e) {
21936       {
21937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (std::exception& e) {
21940       {
21941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21942       };
21943     } catch (...) {
21944       {
21945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21946       };
21947     }
21948   }
21949   jresult = (void *)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21955   void * jresult ;
21956   Dali::BaseHandle arg1 ;
21957   Dali::BaseHandle *argp1 ;
21958   Dali::Sampler result;
21959
21960   argp1 = (Dali::BaseHandle *)jarg1;
21961   if (!argp1) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21963     return 0;
21964   }
21965   arg1 = *argp1;
21966   {
21967     try {
21968       result = Dali::Sampler::DownCast(arg1);
21969     } catch (std::out_of_range& e) {
21970       {
21971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (std::exception& e) {
21974       {
21975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21976       };
21977     } catch (...) {
21978       {
21979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21980       };
21981     }
21982   }
21983   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21989   void * jresult ;
21990   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21991   Dali::Sampler *arg2 = 0 ;
21992   Dali::Sampler *result = 0 ;
21993
21994   arg1 = (Dali::Sampler *)jarg1;
21995   arg2 = (Dali::Sampler *)jarg2;
21996   if (!arg2) {
21997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21998     return 0;
21999   }
22000   {
22001     try {
22002       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22003     } catch (std::out_of_range& e) {
22004       {
22005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (std::exception& e) {
22008       {
22009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017   jresult = (void *)result;
22018   return jresult;
22019 }
22020
22021
22022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22023   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22024   Dali::FilterMode::Type arg2 ;
22025   Dali::FilterMode::Type arg3 ;
22026
22027   arg1 = (Dali::Sampler *)jarg1;
22028   arg2 = (Dali::FilterMode::Type)jarg2;
22029   arg3 = (Dali::FilterMode::Type)jarg3;
22030   {
22031     try {
22032       (arg1)->SetFilterMode(arg2,arg3);
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22040       };
22041     } catch (...) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22044       };
22045     }
22046   }
22047 }
22048
22049
22050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22051   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22052   Dali::WrapMode::Type arg2 ;
22053   Dali::WrapMode::Type arg3 ;
22054
22055   arg1 = (Dali::Sampler *)jarg1;
22056   arg2 = (Dali::WrapMode::Type)jarg2;
22057   arg3 = (Dali::WrapMode::Type)jarg3;
22058   {
22059     try {
22060       (arg1)->SetWrapMode(arg2,arg3);
22061     } catch (std::out_of_range& e) {
22062       {
22063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22064       };
22065     } catch (std::exception& e) {
22066       {
22067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22072       };
22073     }
22074   }
22075 }
22076
22077
22078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22079   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22080   Dali::WrapMode::Type arg2 ;
22081   Dali::WrapMode::Type arg3 ;
22082   Dali::WrapMode::Type arg4 ;
22083
22084   arg1 = (Dali::Sampler *)jarg1;
22085   arg2 = (Dali::WrapMode::Type)jarg2;
22086   arg3 = (Dali::WrapMode::Type)jarg3;
22087   arg4 = (Dali::WrapMode::Type)jarg4;
22088   {
22089     try {
22090       (arg1)->SetWrapMode(arg2,arg3,arg4);
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22098       };
22099     } catch (...) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22102       };
22103     }
22104   }
22105 }
22106
22107
22108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22109   void * jresult ;
22110   Dali::TextureSet result;
22111
22112   {
22113     try {
22114       result = Dali::TextureSet::New();
22115     } catch (std::out_of_range& e) {
22116       {
22117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22118       };
22119     } catch (std::exception& e) {
22120       {
22121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (...) {
22124       {
22125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22126       };
22127     }
22128   }
22129   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22130   return jresult;
22131 }
22132
22133
22134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22135   void * jresult ;
22136   Dali::TextureSet *result = 0 ;
22137
22138   {
22139     try {
22140       result = (Dali::TextureSet *)new Dali::TextureSet();
22141     } catch (std::out_of_range& e) {
22142       {
22143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (std::exception& e) {
22146       {
22147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155   jresult = (void *)result;
22156   return jresult;
22157 }
22158
22159
22160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22161   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22162
22163   arg1 = (Dali::TextureSet *)jarg1;
22164   {
22165     try {
22166       delete arg1;
22167     } catch (std::out_of_range& e) {
22168       {
22169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22170       };
22171     } catch (std::exception& e) {
22172       {
22173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22174       };
22175     } catch (...) {
22176       {
22177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22178       };
22179     }
22180   }
22181 }
22182
22183
22184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22185   void * jresult ;
22186   Dali::TextureSet *arg1 = 0 ;
22187   Dali::TextureSet *result = 0 ;
22188
22189   arg1 = (Dali::TextureSet *)jarg1;
22190   if (!arg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22192     return 0;
22193   }
22194   {
22195     try {
22196       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22197     } catch (std::out_of_range& e) {
22198       {
22199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22200       };
22201     } catch (std::exception& e) {
22202       {
22203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22204       };
22205     } catch (...) {
22206       {
22207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22208       };
22209     }
22210   }
22211   jresult = (void *)result;
22212   return jresult;
22213 }
22214
22215
22216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22217   void * jresult ;
22218   Dali::BaseHandle arg1 ;
22219   Dali::BaseHandle *argp1 ;
22220   Dali::TextureSet result;
22221
22222   argp1 = (Dali::BaseHandle *)jarg1;
22223   if (!argp1) {
22224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22225     return 0;
22226   }
22227   arg1 = *argp1;
22228   {
22229     try {
22230       result = Dali::TextureSet::DownCast(arg1);
22231     } catch (std::out_of_range& e) {
22232       {
22233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22234       };
22235     } catch (std::exception& e) {
22236       {
22237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22242       };
22243     }
22244   }
22245   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22246   return jresult;
22247 }
22248
22249
22250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22251   void * jresult ;
22252   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22253   Dali::TextureSet *arg2 = 0 ;
22254   Dali::TextureSet *result = 0 ;
22255
22256   arg1 = (Dali::TextureSet *)jarg1;
22257   arg2 = (Dali::TextureSet *)jarg2;
22258   if (!arg2) {
22259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22260     return 0;
22261   }
22262   {
22263     try {
22264       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22265     } catch (std::out_of_range& e) {
22266       {
22267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22268       };
22269     } catch (std::exception& e) {
22270       {
22271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22276       };
22277     }
22278   }
22279   jresult = (void *)result;
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22285   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22286   size_t arg2 ;
22287   Dali::Texture arg3 ;
22288   Dali::Texture *argp3 ;
22289
22290   arg1 = (Dali::TextureSet *)jarg1;
22291   arg2 = (size_t)jarg2;
22292   argp3 = (Dali::Texture *)jarg3;
22293   if (!argp3) {
22294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22295     return ;
22296   }
22297   arg3 = *argp3;
22298   {
22299     try {
22300       (arg1)->SetTexture(arg2,arg3);
22301     } catch (std::out_of_range& e) {
22302       {
22303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22304       };
22305     } catch (std::exception& e) {
22306       {
22307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22308       };
22309     } catch (...) {
22310       {
22311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22312       };
22313     }
22314   }
22315 }
22316
22317
22318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22319   void * jresult ;
22320   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22321   size_t arg2 ;
22322   Dali::Texture result;
22323
22324   arg1 = (Dali::TextureSet *)jarg1;
22325   arg2 = (size_t)jarg2;
22326   {
22327     try {
22328       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22329     } catch (std::out_of_range& e) {
22330       {
22331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22332       };
22333     } catch (std::exception& e) {
22334       {
22335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22336       };
22337     } catch (...) {
22338       {
22339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22340       };
22341     }
22342   }
22343   jresult = new Dali::Texture((const Dali::Texture &)result);
22344   return jresult;
22345 }
22346
22347
22348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22349   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22350   size_t arg2 ;
22351   Dali::Sampler arg3 ;
22352   Dali::Sampler *argp3 ;
22353
22354   arg1 = (Dali::TextureSet *)jarg1;
22355   arg2 = (size_t)jarg2;
22356   argp3 = (Dali::Sampler *)jarg3;
22357   if (!argp3) {
22358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22359     return ;
22360   }
22361   arg3 = *argp3;
22362   {
22363     try {
22364       (arg1)->SetSampler(arg2,arg3);
22365     } catch (std::out_of_range& e) {
22366       {
22367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22368       };
22369     } catch (std::exception& e) {
22370       {
22371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22372       };
22373     } catch (...) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22376       };
22377     }
22378   }
22379 }
22380
22381
22382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22383   void * jresult ;
22384   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22385   size_t arg2 ;
22386   Dali::Sampler result;
22387
22388   arg1 = (Dali::TextureSet *)jarg1;
22389   arg2 = (size_t)jarg2;
22390   {
22391     try {
22392       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22393     } catch (std::out_of_range& e) {
22394       {
22395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22396       };
22397     } catch (std::exception& e) {
22398       {
22399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (...) {
22402       {
22403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22404       };
22405     }
22406   }
22407   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22408   return jresult;
22409 }
22410
22411
22412 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22413   unsigned long jresult ;
22414   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22415   size_t result;
22416
22417   arg1 = (Dali::TextureSet *)jarg1;
22418   {
22419     try {
22420       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22432       };
22433     }
22434   }
22435   jresult = (unsigned long)result;
22436   return jresult;
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22441   void * jresult ;
22442   Dali::Property::Map *arg1 = 0 ;
22443   Dali::PropertyBuffer result;
22444
22445   arg1 = (Dali::Property::Map *)jarg1;
22446   if (!arg1) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22448     return 0;
22449   }
22450   {
22451     try {
22452       result = Dali::PropertyBuffer::New(*arg1);
22453     } catch (std::out_of_range& e) {
22454       {
22455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22456       };
22457     } catch (std::exception& e) {
22458       {
22459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22460       };
22461     } catch (...) {
22462       {
22463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22464       };
22465     }
22466   }
22467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22473   void * jresult ;
22474   Dali::PropertyBuffer *result = 0 ;
22475
22476   {
22477     try {
22478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22479     } catch (std::out_of_range& e) {
22480       {
22481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (std::exception& e) {
22484       {
22485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493   jresult = (void *)result;
22494   return jresult;
22495 }
22496
22497
22498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22499   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22500
22501   arg1 = (Dali::PropertyBuffer *)jarg1;
22502   {
22503     try {
22504       delete arg1;
22505     } catch (std::out_of_range& e) {
22506       {
22507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22508       };
22509     } catch (std::exception& e) {
22510       {
22511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22516       };
22517     }
22518   }
22519 }
22520
22521
22522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22523   void * jresult ;
22524   Dali::PropertyBuffer *arg1 = 0 ;
22525   Dali::PropertyBuffer *result = 0 ;
22526
22527   arg1 = (Dali::PropertyBuffer *)jarg1;
22528   if (!arg1) {
22529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22530     return 0;
22531   }
22532   {
22533     try {
22534       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22535     } catch (std::out_of_range& e) {
22536       {
22537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22538       };
22539     } catch (std::exception& e) {
22540       {
22541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22542       };
22543     } catch (...) {
22544       {
22545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22546       };
22547     }
22548   }
22549   jresult = (void *)result;
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22555   void * jresult ;
22556   Dali::BaseHandle arg1 ;
22557   Dali::BaseHandle *argp1 ;
22558   Dali::PropertyBuffer result;
22559
22560   argp1 = (Dali::BaseHandle *)jarg1;
22561   if (!argp1) {
22562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22563     return 0;
22564   }
22565   arg1 = *argp1;
22566   {
22567     try {
22568       result = Dali::PropertyBuffer::DownCast(arg1);
22569     } catch (std::out_of_range& e) {
22570       {
22571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22572       };
22573     } catch (std::exception& e) {
22574       {
22575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22576       };
22577     } catch (...) {
22578       {
22579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22580       };
22581     }
22582   }
22583   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22584   return jresult;
22585 }
22586
22587
22588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22589   void * jresult ;
22590   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22591   Dali::PropertyBuffer *arg2 = 0 ;
22592   Dali::PropertyBuffer *result = 0 ;
22593
22594   arg1 = (Dali::PropertyBuffer *)jarg1;
22595   arg2 = (Dali::PropertyBuffer *)jarg2;
22596   if (!arg2) {
22597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22598     return 0;
22599   }
22600   {
22601     try {
22602       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (...) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22614       };
22615     }
22616   }
22617   jresult = (void *)result;
22618   return jresult;
22619 }
22620
22621
22622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22623   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22624   void *arg2 = (void *) 0 ;
22625   std::size_t arg3 ;
22626
22627   arg1 = (Dali::PropertyBuffer *)jarg1;
22628   arg2 = jarg2;
22629   arg3 = (std::size_t)jarg3;
22630   {
22631     try {
22632       (arg1)->SetData((void const *)arg2,arg3);
22633     } catch (std::out_of_range& e) {
22634       {
22635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22636       };
22637     } catch (std::exception& e) {
22638       {
22639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (...) {
22642       {
22643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22644       };
22645     }
22646   }
22647 }
22648
22649
22650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22651   unsigned long jresult ;
22652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22653   std::size_t result;
22654
22655   arg1 = (Dali::PropertyBuffer *)jarg1;
22656   {
22657     try {
22658       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22659     } catch (std::out_of_range& e) {
22660       {
22661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22662       };
22663     } catch (std::exception& e) {
22664       {
22665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22666       };
22667     } catch (...) {
22668       {
22669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22670       };
22671     }
22672   }
22673   jresult = (unsigned long)result;
22674   return jresult;
22675 }
22676
22677
22678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22679   void * jresult ;
22680   Dali::Geometry result;
22681
22682   {
22683     try {
22684       result = Dali::Geometry::New();
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (...) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22696       };
22697     }
22698   }
22699   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22705   void * jresult ;
22706   Dali::Geometry *result = 0 ;
22707
22708   {
22709     try {
22710       result = (Dali::Geometry *)new Dali::Geometry();
22711     } catch (std::out_of_range& e) {
22712       {
22713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22714       };
22715     } catch (std::exception& e) {
22716       {
22717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22718       };
22719     } catch (...) {
22720       {
22721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22722       };
22723     }
22724   }
22725   jresult = (void *)result;
22726   return jresult;
22727 }
22728
22729
22730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22731   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22732
22733   arg1 = (Dali::Geometry *)jarg1;
22734   {
22735     try {
22736       delete arg1;
22737     } catch (std::out_of_range& e) {
22738       {
22739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22740       };
22741     } catch (std::exception& e) {
22742       {
22743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22744       };
22745     } catch (...) {
22746       {
22747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22748       };
22749     }
22750   }
22751 }
22752
22753
22754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22755   void * jresult ;
22756   Dali::Geometry *arg1 = 0 ;
22757   Dali::Geometry *result = 0 ;
22758
22759   arg1 = (Dali::Geometry *)jarg1;
22760   if (!arg1) {
22761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22762     return 0;
22763   }
22764   {
22765     try {
22766       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (...) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22778       };
22779     }
22780   }
22781   jresult = (void *)result;
22782   return jresult;
22783 }
22784
22785
22786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22787   void * jresult ;
22788   Dali::BaseHandle arg1 ;
22789   Dali::BaseHandle *argp1 ;
22790   Dali::Geometry result;
22791
22792   argp1 = (Dali::BaseHandle *)jarg1;
22793   if (!argp1) {
22794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22795     return 0;
22796   }
22797   arg1 = *argp1;
22798   {
22799     try {
22800       result = Dali::Geometry::DownCast(arg1);
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22808       };
22809     } catch (...) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22812       };
22813     }
22814   }
22815   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22816   return jresult;
22817 }
22818
22819
22820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22821   void * jresult ;
22822   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22823   Dali::Geometry *arg2 = 0 ;
22824   Dali::Geometry *result = 0 ;
22825
22826   arg1 = (Dali::Geometry *)jarg1;
22827   arg2 = (Dali::Geometry *)jarg2;
22828   if (!arg2) {
22829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22830     return 0;
22831   }
22832   {
22833     try {
22834       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22835     } catch (std::out_of_range& e) {
22836       {
22837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22838       };
22839     } catch (std::exception& e) {
22840       {
22841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22842       };
22843     } catch (...) {
22844       {
22845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22846       };
22847     }
22848   }
22849   jresult = (void *)result;
22850   return jresult;
22851 }
22852
22853
22854 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22855   unsigned long jresult ;
22856   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22857   Dali::PropertyBuffer *arg2 = 0 ;
22858   std::size_t result;
22859
22860   arg1 = (Dali::Geometry *)jarg1;
22861   arg2 = (Dali::PropertyBuffer *)jarg2;
22862   if (!arg2) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22864     return 0;
22865   }
22866   {
22867     try {
22868       result = (arg1)->AddVertexBuffer(*arg2);
22869     } catch (std::out_of_range& e) {
22870       {
22871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22872       };
22873     } catch (std::exception& e) {
22874       {
22875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22876       };
22877     } catch (...) {
22878       {
22879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22880       };
22881     }
22882   }
22883   jresult = (unsigned long)result;
22884   return jresult;
22885 }
22886
22887
22888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22889   unsigned long jresult ;
22890   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22891   std::size_t result;
22892
22893   arg1 = (Dali::Geometry *)jarg1;
22894   {
22895     try {
22896       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (...) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22908       };
22909     }
22910   }
22911   jresult = (unsigned long)result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22918   std::size_t arg2 ;
22919
22920   arg1 = (Dali::Geometry *)jarg1;
22921   arg2 = (std::size_t)jarg2;
22922   {
22923     try {
22924       (arg1)->RemoveVertexBuffer(arg2);
22925     } catch (std::out_of_range& e) {
22926       {
22927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22928       };
22929     } catch (std::exception& e) {
22930       {
22931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22932       };
22933     } catch (...) {
22934       {
22935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22936       };
22937     }
22938   }
22939 }
22940
22941
22942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22943   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22944   unsigned short *arg2 = (unsigned short *) 0 ;
22945   size_t arg3 ;
22946
22947   arg1 = (Dali::Geometry *)jarg1;
22948   arg2 = jarg2;
22949   arg3 = (size_t)jarg3;
22950   {
22951     try {
22952       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22953     } catch (std::out_of_range& e) {
22954       {
22955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22956       };
22957     } catch (std::exception& e) {
22958       {
22959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22960       };
22961     } catch (...) {
22962       {
22963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22964       };
22965     }
22966   }
22967
22968
22969 }
22970
22971
22972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22973   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22974   Dali::Geometry::Type arg2 ;
22975
22976   arg1 = (Dali::Geometry *)jarg1;
22977   arg2 = (Dali::Geometry::Type)jarg2;
22978   {
22979     try {
22980       (arg1)->SetType(arg2);
22981     } catch (std::out_of_range& e) {
22982       {
22983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22984       };
22985     } catch (std::exception& e) {
22986       {
22987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22988       };
22989     } catch (...) {
22990       {
22991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22992       };
22993     }
22994   }
22995 }
22996
22997
22998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22999   int jresult ;
23000   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
23001   Dali::Geometry::Type result;
23002
23003   arg1 = (Dali::Geometry *)jarg1;
23004   {
23005     try {
23006       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23007     } catch (std::out_of_range& e) {
23008       {
23009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23010       };
23011     } catch (std::exception& e) {
23012       {
23013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23014       };
23015     } catch (...) {
23016       {
23017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23018       };
23019     }
23020   }
23021   jresult = (int)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23027   void * jresult ;
23028   Dali::Shader::Hint *result = 0 ;
23029
23030   {
23031     try {
23032       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23033     } catch (std::out_of_range& e) {
23034       {
23035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23036       };
23037     } catch (std::exception& e) {
23038       {
23039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23040       };
23041     } catch (...) {
23042       {
23043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23044       };
23045     }
23046   }
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23053   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23054
23055   arg1 = (Dali::Shader::Hint *)jarg1;
23056   {
23057     try {
23058       delete arg1;
23059     } catch (std::out_of_range& e) {
23060       {
23061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23062       };
23063     } catch (std::exception& e) {
23064       {
23065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23066       };
23067     } catch (...) {
23068       {
23069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23070       };
23071     }
23072   }
23073 }
23074
23075
23076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23077   int jresult ;
23078   int result;
23079
23080   result = (int)Dali::Shader::Property::PROGRAM;
23081   jresult = (int)result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23087   void * jresult ;
23088   Dali::Shader::Property *result = 0 ;
23089
23090   {
23091     try {
23092       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23093     } catch (std::out_of_range& e) {
23094       {
23095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23096       };
23097     } catch (std::exception& e) {
23098       {
23099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23100       };
23101     } catch (...) {
23102       {
23103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23104       };
23105     }
23106   }
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23113   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23114
23115   arg1 = (Dali::Shader::Property *)jarg1;
23116   {
23117     try {
23118       delete arg1;
23119     } catch (std::out_of_range& e) {
23120       {
23121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23122       };
23123     } catch (std::exception& e) {
23124       {
23125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23126       };
23127     } catch (...) {
23128       {
23129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23130       };
23131     }
23132   }
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23137   void * jresult ;
23138   std::string *arg1 = 0 ;
23139   std::string *arg2 = 0 ;
23140   Dali::Shader::Hint::Value arg3 ;
23141   Dali::Shader result;
23142
23143   if (!jarg1) {
23144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23145     return 0;
23146   }
23147   std::string arg1_str(jarg1);
23148   arg1 = &arg1_str;
23149   if (!jarg2) {
23150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23151     return 0;
23152   }
23153   std::string arg2_str(jarg2);
23154   arg2 = &arg2_str;
23155   arg3 = (Dali::Shader::Hint::Value)jarg3;
23156   {
23157     try {
23158       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23159     } catch (std::out_of_range& e) {
23160       {
23161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23162       };
23163     } catch (std::exception& e) {
23164       {
23165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23166       };
23167     } catch (...) {
23168       {
23169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23170       };
23171     }
23172   }
23173   jresult = new Dali::Shader((const Dali::Shader &)result);
23174
23175   //argout typemap for const std::string&
23176
23177
23178   //argout typemap for const std::string&
23179
23180   return jresult;
23181 }
23182
23183
23184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23185   void * jresult ;
23186   std::string *arg1 = 0 ;
23187   std::string *arg2 = 0 ;
23188   Dali::Shader result;
23189
23190   if (!jarg1) {
23191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23192     return 0;
23193   }
23194   std::string arg1_str(jarg1);
23195   arg1 = &arg1_str;
23196   if (!jarg2) {
23197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23198     return 0;
23199   }
23200   std::string arg2_str(jarg2);
23201   arg2 = &arg2_str;
23202   {
23203     try {
23204       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23205     } catch (std::out_of_range& e) {
23206       {
23207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23208       };
23209     } catch (std::exception& e) {
23210       {
23211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23212       };
23213     } catch (...) {
23214       {
23215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23216       };
23217     }
23218   }
23219   jresult = new Dali::Shader((const Dali::Shader &)result);
23220
23221   //argout typemap for const std::string&
23222
23223
23224   //argout typemap for const std::string&
23225
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23231   void * jresult ;
23232   Dali::Shader *result = 0 ;
23233
23234   {
23235     try {
23236       result = (Dali::Shader *)new Dali::Shader();
23237     } catch (std::out_of_range& e) {
23238       {
23239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23240       };
23241     } catch (std::exception& e) {
23242       {
23243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23244       };
23245     } catch (...) {
23246       {
23247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23248       };
23249     }
23250   }
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23257   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23258
23259   arg1 = (Dali::Shader *)jarg1;
23260   {
23261     try {
23262       delete arg1;
23263     } catch (std::out_of_range& e) {
23264       {
23265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23266       };
23267     } catch (std::exception& e) {
23268       {
23269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23270       };
23271     } catch (...) {
23272       {
23273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23274       };
23275     }
23276   }
23277 }
23278
23279
23280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23281   void * jresult ;
23282   Dali::Shader *arg1 = 0 ;
23283   Dali::Shader *result = 0 ;
23284
23285   arg1 = (Dali::Shader *)jarg1;
23286   if (!arg1) {
23287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23288     return 0;
23289   }
23290   {
23291     try {
23292       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23293     } catch (std::out_of_range& e) {
23294       {
23295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23296       };
23297     } catch (std::exception& e) {
23298       {
23299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23300       };
23301     } catch (...) {
23302       {
23303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23304       };
23305     }
23306   }
23307   jresult = (void *)result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23313   void * jresult ;
23314   Dali::BaseHandle arg1 ;
23315   Dali::BaseHandle *argp1 ;
23316   Dali::Shader result;
23317
23318   argp1 = (Dali::BaseHandle *)jarg1;
23319   if (!argp1) {
23320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23321     return 0;
23322   }
23323   arg1 = *argp1;
23324   {
23325     try {
23326       result = Dali::Shader::DownCast(arg1);
23327     } catch (std::out_of_range& e) {
23328       {
23329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23330       };
23331     } catch (std::exception& e) {
23332       {
23333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23334       };
23335     } catch (...) {
23336       {
23337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23338       };
23339     }
23340   }
23341   jresult = new Dali::Shader((const Dali::Shader &)result);
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23347   void * jresult ;
23348   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23349   Dali::Shader *arg2 = 0 ;
23350   Dali::Shader *result = 0 ;
23351
23352   arg1 = (Dali::Shader *)jarg1;
23353   arg2 = (Dali::Shader *)jarg2;
23354   if (!arg2) {
23355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23356     return 0;
23357   }
23358   {
23359     try {
23360       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23361     } catch (std::out_of_range& e) {
23362       {
23363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23364       };
23365     } catch (std::exception& e) {
23366       {
23367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23368       };
23369     } catch (...) {
23370       {
23371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23372       };
23373     }
23374   }
23375   jresult = (void *)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::BLEND_MODE;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23521   int jresult ;
23522   int result;
23523
23524   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23525   jresult = (int)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23531   int jresult ;
23532   int result;
23533
23534   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23535   jresult = (int)result;
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23541   int jresult ;
23542   int result;
23543
23544   result = (int)Dali::Renderer::Property::RENDER_MODE;
23545   jresult = (int)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23551   int jresult ;
23552   int result;
23553
23554   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23555   jresult = (int)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23561   int jresult ;
23562   int result;
23563
23564   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23565   jresult = (int)result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23571   int jresult ;
23572   int result;
23573
23574   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23575   jresult = (int)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23581   int jresult ;
23582   int result;
23583
23584   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23591   int jresult ;
23592   int result;
23593
23594   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23601   int jresult ;
23602   int result;
23603
23604   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23605   jresult = (int)result;
23606   return jresult;
23607 }
23608
23609
23610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23611   int jresult ;
23612   int result;
23613
23614   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23615   jresult = (int)result;
23616   return jresult;
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23621   void * jresult ;
23622   Dali::Renderer::Property *result = 0 ;
23623
23624   {
23625     try {
23626       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23627     } catch (std::out_of_range& e) {
23628       {
23629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23630       };
23631     } catch (std::exception& e) {
23632       {
23633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (...) {
23636       {
23637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23638       };
23639     }
23640   }
23641   jresult = (void *)result;
23642   return jresult;
23643 }
23644
23645
23646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23647   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23648
23649   arg1 = (Dali::Renderer::Property *)jarg1;
23650   {
23651     try {
23652       delete arg1;
23653     } catch (std::out_of_range& e) {
23654       {
23655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23656       };
23657     } catch (std::exception& e) {
23658       {
23659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23660       };
23661     } catch (...) {
23662       {
23663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23664       };
23665     }
23666   }
23667 }
23668
23669
23670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23671   void * jresult ;
23672   Dali::Geometry *arg1 = 0 ;
23673   Dali::Shader *arg2 = 0 ;
23674   Dali::Renderer result;
23675
23676   arg1 = (Dali::Geometry *)jarg1;
23677   if (!arg1) {
23678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23679     return 0;
23680   }
23681   arg2 = (Dali::Shader *)jarg2;
23682   if (!arg2) {
23683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23684     return 0;
23685   }
23686   {
23687     try {
23688       result = Dali::Renderer::New(*arg1,*arg2);
23689     } catch (std::out_of_range& e) {
23690       {
23691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23692       };
23693     } catch (std::exception& e) {
23694       {
23695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23700       };
23701     }
23702   }
23703   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23704   return jresult;
23705 }
23706
23707
23708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23709   void * jresult ;
23710   Dali::Renderer *result = 0 ;
23711
23712   {
23713     try {
23714       result = (Dali::Renderer *)new Dali::Renderer();
23715     } catch (std::out_of_range& e) {
23716       {
23717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (std::exception& e) {
23720       {
23721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729   jresult = (void *)result;
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23735   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23736
23737   arg1 = (Dali::Renderer *)jarg1;
23738   {
23739     try {
23740       delete arg1;
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23748       };
23749     } catch (...) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23752       };
23753     }
23754   }
23755 }
23756
23757
23758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23759   void * jresult ;
23760   Dali::Renderer *arg1 = 0 ;
23761   Dali::Renderer *result = 0 ;
23762
23763   arg1 = (Dali::Renderer *)jarg1;
23764   if (!arg1) {
23765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23766     return 0;
23767   }
23768   {
23769     try {
23770       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23782       };
23783     }
23784   }
23785   jresult = (void *)result;
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23791   void * jresult ;
23792   Dali::BaseHandle arg1 ;
23793   Dali::BaseHandle *argp1 ;
23794   Dali::Renderer result;
23795
23796   argp1 = (Dali::BaseHandle *)jarg1;
23797   if (!argp1) {
23798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23799     return 0;
23800   }
23801   arg1 = *argp1;
23802   {
23803     try {
23804       result = Dali::Renderer::DownCast(arg1);
23805     } catch (std::out_of_range& e) {
23806       {
23807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23808       };
23809     } catch (std::exception& e) {
23810       {
23811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (...) {
23814       {
23815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23816       };
23817     }
23818   }
23819   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23820   return jresult;
23821 }
23822
23823
23824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23825   void * jresult ;
23826   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23827   Dali::Renderer *arg2 = 0 ;
23828   Dali::Renderer *result = 0 ;
23829
23830   arg1 = (Dali::Renderer *)jarg1;
23831   arg2 = (Dali::Renderer *)jarg2;
23832   if (!arg2) {
23833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23834     return 0;
23835   }
23836   {
23837     try {
23838       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23839     } catch (std::out_of_range& e) {
23840       {
23841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23842       };
23843     } catch (std::exception& e) {
23844       {
23845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (...) {
23848       {
23849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23850       };
23851     }
23852   }
23853   jresult = (void *)result;
23854   return jresult;
23855 }
23856
23857
23858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23859   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23860   Dali::Geometry *arg2 = 0 ;
23861
23862   arg1 = (Dali::Renderer *)jarg1;
23863   arg2 = (Dali::Geometry *)jarg2;
23864   if (!arg2) {
23865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23866     return ;
23867   }
23868   {
23869     try {
23870       (arg1)->SetGeometry(*arg2);
23871     } catch (std::out_of_range& e) {
23872       {
23873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23874       };
23875     } catch (std::exception& e) {
23876       {
23877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23878       };
23879     } catch (...) {
23880       {
23881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23882       };
23883     }
23884   }
23885 }
23886
23887
23888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23889   void * jresult ;
23890   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23891   Dali::Geometry result;
23892
23893   arg1 = (Dali::Renderer *)jarg1;
23894   {
23895     try {
23896       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23897     } catch (std::out_of_range& e) {
23898       {
23899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (std::exception& e) {
23902       {
23903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (...) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23908       };
23909     }
23910   }
23911   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23917   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23918   int arg2 ;
23919   int arg3 ;
23920
23921   arg1 = (Dali::Renderer *)jarg1;
23922   arg2 = (int)jarg2;
23923   arg3 = (int)jarg3;
23924   {
23925     try {
23926       (arg1)->SetIndexRange(arg2,arg3);
23927     } catch (std::out_of_range& e) {
23928       {
23929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23930       };
23931     } catch (std::exception& e) {
23932       {
23933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23934       };
23935     } catch (...) {
23936       {
23937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23938       };
23939     }
23940   }
23941 }
23942
23943
23944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23945   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23946   Dali::TextureSet *arg2 = 0 ;
23947
23948   arg1 = (Dali::Renderer *)jarg1;
23949   arg2 = (Dali::TextureSet *)jarg2;
23950   if (!arg2) {
23951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23952     return ;
23953   }
23954   {
23955     try {
23956       (arg1)->SetTextures(*arg2);
23957     } catch (std::out_of_range& e) {
23958       {
23959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23960       };
23961     } catch (std::exception& e) {
23962       {
23963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23964       };
23965     } catch (...) {
23966       {
23967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23968       };
23969     }
23970   }
23971 }
23972
23973
23974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23975   void * jresult ;
23976   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23977   Dali::TextureSet result;
23978
23979   arg1 = (Dali::Renderer *)jarg1;
23980   {
23981     try {
23982       result = ((Dali::Renderer const *)arg1)->GetTextures();
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24003   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24004   Dali::Shader *arg2 = 0 ;
24005
24006   arg1 = (Dali::Renderer *)jarg1;
24007   arg2 = (Dali::Shader *)jarg2;
24008   if (!arg2) {
24009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24010     return ;
24011   }
24012   {
24013     try {
24014       (arg1)->SetShader(*arg2);
24015     } catch (std::out_of_range& e) {
24016       {
24017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24018       };
24019     } catch (std::exception& e) {
24020       {
24021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24022       };
24023     } catch (...) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24026       };
24027     }
24028   }
24029 }
24030
24031
24032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24033   void * jresult ;
24034   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24035   Dali::Shader result;
24036
24037   arg1 = (Dali::Renderer *)jarg1;
24038   {
24039     try {
24040       result = ((Dali::Renderer const *)arg1)->GetShader();
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24048       };
24049     } catch (...) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24052       };
24053     }
24054   }
24055   jresult = new Dali::Shader((const Dali::Shader &)result);
24056   return jresult;
24057 }
24058
24059
24060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24061   void * jresult ;
24062   Dali::FrameBuffer::Attachment *result = 0 ;
24063
24064   {
24065     try {
24066       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24067     } catch (std::out_of_range& e) {
24068       {
24069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24070       };
24071     } catch (std::exception& e) {
24072       {
24073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24074       };
24075     } catch (...) {
24076       {
24077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24078       };
24079     }
24080   }
24081   jresult = (void *)result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24087   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24088
24089   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24090   {
24091     try {
24092       delete arg1;
24093     } catch (std::out_of_range& e) {
24094       {
24095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24096       };
24097     } catch (std::exception& e) {
24098       {
24099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24104       };
24105     }
24106   }
24107 }
24108
24109
24110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24111   void * jresult ;
24112   unsigned int arg1 ;
24113   unsigned int arg2 ;
24114   unsigned int arg3 ;
24115   Dali::FrameBuffer result;
24116
24117   arg1 = (unsigned int)jarg1;
24118   arg2 = (unsigned int)jarg2;
24119   arg3 = (unsigned int)jarg3;
24120   {
24121     try {
24122       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24123     } catch (std::out_of_range& e) {
24124       {
24125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (std::exception& e) {
24128       {
24129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24143   void * jresult ;
24144   Dali::FrameBuffer *result = 0 ;
24145
24146   {
24147     try {
24148       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24149     } catch (std::out_of_range& e) {
24150       {
24151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24152       };
24153     } catch (std::exception& e) {
24154       {
24155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (...) {
24158       {
24159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24160       };
24161     }
24162   }
24163   jresult = (void *)result;
24164   return jresult;
24165 }
24166
24167
24168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24169   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24170
24171   arg1 = (Dali::FrameBuffer *)jarg1;
24172   {
24173     try {
24174       delete arg1;
24175     } catch (std::out_of_range& e) {
24176       {
24177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24178       };
24179     } catch (std::exception& e) {
24180       {
24181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24182       };
24183     } catch (...) {
24184       {
24185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24186       };
24187     }
24188   }
24189 }
24190
24191
24192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24193   void * jresult ;
24194   Dali::FrameBuffer *arg1 = 0 ;
24195   Dali::FrameBuffer *result = 0 ;
24196
24197   arg1 = (Dali::FrameBuffer *)jarg1;
24198   if (!arg1) {
24199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24200     return 0;
24201   }
24202   {
24203     try {
24204       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24205     } catch (std::out_of_range& e) {
24206       {
24207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24208       };
24209     } catch (std::exception& e) {
24210       {
24211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24212       };
24213     } catch (...) {
24214       {
24215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24216       };
24217     }
24218   }
24219   jresult = (void *)result;
24220   return jresult;
24221 }
24222
24223
24224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24225   void * jresult ;
24226   Dali::BaseHandle arg1 ;
24227   Dali::BaseHandle *argp1 ;
24228   Dali::FrameBuffer result;
24229
24230   argp1 = (Dali::BaseHandle *)jarg1;
24231   if (!argp1) {
24232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24233     return 0;
24234   }
24235   arg1 = *argp1;
24236   {
24237     try {
24238       result = Dali::FrameBuffer::DownCast(arg1);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24250       };
24251     }
24252   }
24253   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24259   void * jresult ;
24260   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24261   Dali::FrameBuffer *arg2 = 0 ;
24262   Dali::FrameBuffer *result = 0 ;
24263
24264   arg1 = (Dali::FrameBuffer *)jarg1;
24265   arg2 = (Dali::FrameBuffer *)jarg2;
24266   if (!arg2) {
24267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24268     return 0;
24269   }
24270   {
24271     try {
24272       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24273     } catch (std::out_of_range& e) {
24274       {
24275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (std::exception& e) {
24278       {
24279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (...) {
24282       {
24283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24284       };
24285     }
24286   }
24287   jresult = (void *)result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24293   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24294   Dali::Texture *arg2 = 0 ;
24295
24296   arg1 = (Dali::FrameBuffer *)jarg1;
24297   arg2 = (Dali::Texture *)jarg2;
24298   if (!arg2) {
24299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24300     return ;
24301   }
24302   {
24303     try {
24304       (arg1)->AttachColorTexture(*arg2);
24305     } catch (std::out_of_range& e) {
24306       {
24307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24308       };
24309     } catch (std::exception& e) {
24310       {
24311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24312       };
24313     } catch (...) {
24314       {
24315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24316       };
24317     }
24318   }
24319 }
24320
24321
24322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24323   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24324   Dali::Texture *arg2 = 0 ;
24325   unsigned int arg3 ;
24326   unsigned int arg4 ;
24327
24328   arg1 = (Dali::FrameBuffer *)jarg1;
24329   arg2 = (Dali::Texture *)jarg2;
24330   if (!arg2) {
24331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24332     return ;
24333   }
24334   arg3 = (unsigned int)jarg3;
24335   arg4 = (unsigned int)jarg4;
24336   {
24337     try {
24338       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24339     } catch (std::out_of_range& e) {
24340       {
24341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24342       };
24343     } catch (std::exception& e) {
24344       {
24345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24346       };
24347     } catch (...) {
24348       {
24349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24350       };
24351     }
24352   }
24353 }
24354
24355
24356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24357   void * jresult ;
24358   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24359   Dali::Texture result;
24360
24361   arg1 = (Dali::FrameBuffer *)jarg1;
24362   {
24363     try {
24364       result = (arg1)->GetColorTexture();
24365     } catch (std::out_of_range& e) {
24366       {
24367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24368       };
24369     } catch (std::exception& e) {
24370       {
24371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24372       };
24373     } catch (...) {
24374       {
24375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24376       };
24377     }
24378   }
24379   jresult = new Dali::Texture((const Dali::Texture &)result);
24380   return jresult;
24381 }
24382
24383
24384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24385   void * jresult ;
24386   Dali::RenderTaskList *result = 0 ;
24387
24388   {
24389     try {
24390       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24391     } catch (std::out_of_range& e) {
24392       {
24393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (std::exception& e) {
24396       {
24397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405   jresult = (void *)result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24411   void * jresult ;
24412   Dali::BaseHandle arg1 ;
24413   Dali::BaseHandle *argp1 ;
24414   Dali::RenderTaskList result;
24415
24416   argp1 = (Dali::BaseHandle *)jarg1;
24417   if (!argp1) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24419     return 0;
24420   }
24421   arg1 = *argp1;
24422   {
24423     try {
24424       result = Dali::RenderTaskList::DownCast(arg1);
24425     } catch (std::out_of_range& e) {
24426       {
24427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24428       };
24429     } catch (std::exception& e) {
24430       {
24431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24432       };
24433     } catch (...) {
24434       {
24435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24436       };
24437     }
24438   }
24439   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24440   return jresult;
24441 }
24442
24443
24444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24445   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24446
24447   arg1 = (Dali::RenderTaskList *)jarg1;
24448   {
24449     try {
24450       delete arg1;
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24458       };
24459     } catch (...) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24462       };
24463     }
24464   }
24465 }
24466
24467
24468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24469   void * jresult ;
24470   Dali::RenderTaskList *arg1 = 0 ;
24471   Dali::RenderTaskList *result = 0 ;
24472
24473   arg1 = (Dali::RenderTaskList *)jarg1;
24474   if (!arg1) {
24475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24476     return 0;
24477   }
24478   {
24479     try {
24480       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24481     } catch (std::out_of_range& e) {
24482       {
24483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (std::exception& e) {
24486       {
24487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (...) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24492       };
24493     }
24494   }
24495   jresult = (void *)result;
24496   return jresult;
24497 }
24498
24499
24500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24501   void * jresult ;
24502   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24503   Dali::RenderTaskList *arg2 = 0 ;
24504   Dali::RenderTaskList *result = 0 ;
24505
24506   arg1 = (Dali::RenderTaskList *)jarg1;
24507   arg2 = (Dali::RenderTaskList *)jarg2;
24508   if (!arg2) {
24509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24510     return 0;
24511   }
24512   {
24513     try {
24514       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24515     } catch (std::out_of_range& e) {
24516       {
24517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24518       };
24519     } catch (std::exception& e) {
24520       {
24521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (...) {
24524       {
24525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24526       };
24527     }
24528   }
24529   jresult = (void *)result;
24530   return jresult;
24531 }
24532
24533
24534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24535   void * jresult ;
24536   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24537   Dali::RenderTask result;
24538
24539   arg1 = (Dali::RenderTaskList *)jarg1;
24540   {
24541     try {
24542       result = (arg1)->CreateTask();
24543     } catch (std::out_of_range& e) {
24544       {
24545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (std::exception& e) {
24548       {
24549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24550       };
24551     } catch (...) {
24552       {
24553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24554       };
24555     }
24556   }
24557   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24558   return jresult;
24559 }
24560
24561
24562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24563   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24564   Dali::RenderTask arg2 ;
24565   Dali::RenderTask *argp2 ;
24566
24567   arg1 = (Dali::RenderTaskList *)jarg1;
24568   argp2 = (Dali::RenderTask *)jarg2;
24569   if (!argp2) {
24570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24571     return ;
24572   }
24573   arg2 = *argp2;
24574   {
24575     try {
24576       (arg1)->RemoveTask(arg2);
24577     } catch (std::out_of_range& e) {
24578       {
24579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24580       };
24581     } catch (std::exception& e) {
24582       {
24583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24588       };
24589     }
24590   }
24591 }
24592
24593
24594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24595   unsigned int jresult ;
24596   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24597   unsigned int result;
24598
24599   arg1 = (Dali::RenderTaskList *)jarg1;
24600   {
24601     try {
24602       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24603     } catch (std::out_of_range& e) {
24604       {
24605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (std::exception& e) {
24608       {
24609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24610       };
24611     } catch (...) {
24612       {
24613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24614       };
24615     }
24616   }
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621
24622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24623   void * jresult ;
24624   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24625   unsigned int arg2 ;
24626   Dali::RenderTask result;
24627
24628   arg1 = (Dali::RenderTaskList *)jarg1;
24629   arg2 = (unsigned int)jarg2;
24630   {
24631     try {
24632       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24633     } catch (std::out_of_range& e) {
24634       {
24635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (std::exception& e) {
24638       {
24639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24640       };
24641     } catch (...) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24644       };
24645     }
24646   }
24647   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24653   int jresult ;
24654   int result;
24655
24656   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24657   jresult = (int)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24663   int jresult ;
24664   int result;
24665
24666   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24667   jresult = (int)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24673   int jresult ;
24674   int result;
24675
24676   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24677   jresult = (int)result;
24678   return jresult;
24679 }
24680
24681
24682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24683   int jresult ;
24684   int result;
24685
24686   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24687   jresult = (int)result;
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24693   void * jresult ;
24694   Dali::RenderTask::Property *result = 0 ;
24695
24696   {
24697     try {
24698       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24699     } catch (std::out_of_range& e) {
24700       {
24701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24702       };
24703     } catch (std::exception& e) {
24704       {
24705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24706       };
24707     } catch (...) {
24708       {
24709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24710       };
24711     }
24712   }
24713   jresult = (void *)result;
24714   return jresult;
24715 }
24716
24717
24718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24719   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24720
24721   arg1 = (Dali::RenderTask::Property *)jarg1;
24722   {
24723     try {
24724       delete arg1;
24725     } catch (std::out_of_range& e) {
24726       {
24727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24728       };
24729     } catch (std::exception& e) {
24730       {
24731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24736       };
24737     }
24738   }
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24743   void * jresult ;
24744   bool (*result)(Dali::Vector2 &) = 0 ;
24745
24746   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24747   jresult = (void *)result;
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24753   void * jresult ;
24754   bool (*result)(Dali::Vector2 &) = 0 ;
24755
24756   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24757   jresult = (void *)result;
24758   return jresult;
24759 }
24760
24761
24762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24763   unsigned int jresult ;
24764   bool result;
24765
24766   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24767   jresult = result;
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24773   unsigned int jresult ;
24774   bool result;
24775
24776   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24783   void * jresult ;
24784   Dali::Vector4 *result = 0 ;
24785
24786   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24787   jresult = (void *)result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24793   unsigned int jresult ;
24794   bool result;
24795
24796   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24797   jresult = result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24803   unsigned int jresult ;
24804   bool result;
24805
24806   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24807   jresult = result;
24808   return jresult;
24809 }
24810
24811
24812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24813   unsigned int jresult ;
24814   unsigned int result;
24815
24816   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24817   jresult = result;
24818   return jresult;
24819 }
24820
24821
24822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24823   void * jresult ;
24824   Dali::RenderTask *result = 0 ;
24825
24826   {
24827     try {
24828       result = (Dali::RenderTask *)new Dali::RenderTask();
24829     } catch (std::out_of_range& e) {
24830       {
24831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24832       };
24833     } catch (std::exception& e) {
24834       {
24835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24836       };
24837     } catch (...) {
24838       {
24839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24840       };
24841     }
24842   }
24843   jresult = (void *)result;
24844   return jresult;
24845 }
24846
24847
24848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24849   void * jresult ;
24850   Dali::BaseHandle arg1 ;
24851   Dali::BaseHandle *argp1 ;
24852   Dali::RenderTask result;
24853
24854   argp1 = (Dali::BaseHandle *)jarg1;
24855   if (!argp1) {
24856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24857     return 0;
24858   }
24859   arg1 = *argp1;
24860   {
24861     try {
24862       result = Dali::RenderTask::DownCast(arg1);
24863     } catch (std::out_of_range& e) {
24864       {
24865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24866       };
24867     } catch (std::exception& e) {
24868       {
24869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24870       };
24871     } catch (...) {
24872       {
24873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24874       };
24875     }
24876   }
24877   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24878   return jresult;
24879 }
24880
24881
24882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24883   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24884
24885   arg1 = (Dali::RenderTask *)jarg1;
24886   {
24887     try {
24888       delete arg1;
24889     } catch (std::out_of_range& e) {
24890       {
24891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24892       };
24893     } catch (std::exception& e) {
24894       {
24895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24900       };
24901     }
24902   }
24903 }
24904
24905
24906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24907   void * jresult ;
24908   Dali::RenderTask *arg1 = 0 ;
24909   Dali::RenderTask *result = 0 ;
24910
24911   arg1 = (Dali::RenderTask *)jarg1;
24912   if (!arg1) {
24913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24914     return 0;
24915   }
24916   {
24917     try {
24918       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (...) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24930       };
24931     }
24932   }
24933   jresult = (void *)result;
24934   return jresult;
24935 }
24936
24937
24938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24939   void * jresult ;
24940   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24941   Dali::RenderTask *arg2 = 0 ;
24942   Dali::RenderTask *result = 0 ;
24943
24944   arg1 = (Dali::RenderTask *)jarg1;
24945   arg2 = (Dali::RenderTask *)jarg2;
24946   if (!arg2) {
24947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24948     return 0;
24949   }
24950   {
24951     try {
24952       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24953     } catch (std::out_of_range& e) {
24954       {
24955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24956       };
24957     } catch (std::exception& e) {
24958       {
24959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24960       };
24961     } catch (...) {
24962       {
24963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24964       };
24965     }
24966   }
24967   jresult = (void *)result;
24968   return jresult;
24969 }
24970
24971
24972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24973   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24974   Dali::Actor arg2 ;
24975   Dali::Actor *argp2 ;
24976
24977   arg1 = (Dali::RenderTask *)jarg1;
24978   argp2 = (Dali::Actor *)jarg2;
24979   if (!argp2) {
24980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24981     return ;
24982   }
24983   arg2 = *argp2;
24984   {
24985     try {
24986       (arg1)->SetSourceActor(arg2);
24987     } catch (std::out_of_range& e) {
24988       {
24989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24990       };
24991     } catch (std::exception& e) {
24992       {
24993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24998       };
24999     }
25000   }
25001 }
25002
25003
25004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25005   void * jresult ;
25006   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25007   Dali::Actor result;
25008
25009   arg1 = (Dali::RenderTask *)jarg1;
25010   {
25011     try {
25012       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25013     } catch (std::out_of_range& e) {
25014       {
25015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25016       };
25017     } catch (std::exception& e) {
25018       {
25019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25020       };
25021     } catch (...) {
25022       {
25023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25024       };
25025     }
25026   }
25027   jresult = new Dali::Actor((const Dali::Actor &)result);
25028   return jresult;
25029 }
25030
25031
25032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25033   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25034   bool arg2 ;
25035
25036   arg1 = (Dali::RenderTask *)jarg1;
25037   arg2 = jarg2 ? true : false;
25038   {
25039     try {
25040       (arg1)->SetExclusive(arg2);
25041     } catch (std::out_of_range& e) {
25042       {
25043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25044       };
25045     } catch (std::exception& e) {
25046       {
25047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25048       };
25049     } catch (...) {
25050       {
25051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25052       };
25053     }
25054   }
25055 }
25056
25057
25058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25059   unsigned int jresult ;
25060   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25061   bool result;
25062
25063   arg1 = (Dali::RenderTask *)jarg1;
25064   {
25065     try {
25066       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25067     } catch (std::out_of_range& e) {
25068       {
25069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25070       };
25071     } catch (std::exception& e) {
25072       {
25073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25074       };
25075     } catch (...) {
25076       {
25077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25078       };
25079     }
25080   }
25081   jresult = result;
25082   return jresult;
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25087   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25088   bool arg2 ;
25089
25090   arg1 = (Dali::RenderTask *)jarg1;
25091   arg2 = jarg2 ? true : false;
25092   {
25093     try {
25094       (arg1)->SetInputEnabled(arg2);
25095     } catch (std::out_of_range& e) {
25096       {
25097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25098       };
25099     } catch (std::exception& e) {
25100       {
25101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25102       };
25103     } catch (...) {
25104       {
25105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25106       };
25107     }
25108   }
25109 }
25110
25111
25112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25113   unsigned int jresult ;
25114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25115   bool result;
25116
25117   arg1 = (Dali::RenderTask *)jarg1;
25118   {
25119     try {
25120       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25132       };
25133     }
25134   }
25135   jresult = result;
25136   return jresult;
25137 }
25138
25139
25140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25141   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25142   Dali::CameraActor arg2 ;
25143   Dali::CameraActor *argp2 ;
25144
25145   arg1 = (Dali::RenderTask *)jarg1;
25146   argp2 = (Dali::CameraActor *)jarg2;
25147   if (!argp2) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25149     return ;
25150   }
25151   arg2 = *argp2;
25152   {
25153     try {
25154       (arg1)->SetCameraActor(arg2);
25155     } catch (std::out_of_range& e) {
25156       {
25157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25158       };
25159     } catch (std::exception& e) {
25160       {
25161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25166       };
25167     }
25168   }
25169 }
25170
25171
25172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25173   void * jresult ;
25174   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25175   Dali::CameraActor result;
25176
25177   arg1 = (Dali::RenderTask *)jarg1;
25178   {
25179     try {
25180       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25181     } catch (std::out_of_range& e) {
25182       {
25183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25184       };
25185     } catch (std::exception& e) {
25186       {
25187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25188       };
25189     } catch (...) {
25190       {
25191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25192       };
25193     }
25194   }
25195   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25196   return jresult;
25197 }
25198
25199
25200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25201   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25202   Dali::FrameBufferImage arg2 ;
25203   Dali::FrameBufferImage *argp2 ;
25204
25205   arg1 = (Dali::RenderTask *)jarg1;
25206   argp2 = (Dali::FrameBufferImage *)jarg2;
25207   if (!argp2) {
25208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25209     return ;
25210   }
25211   arg2 = *argp2;
25212   {
25213     try {
25214       (arg1)->SetTargetFrameBuffer(arg2);
25215     } catch (std::out_of_range& e) {
25216       {
25217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25218       };
25219     } catch (std::exception& e) {
25220       {
25221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25222       };
25223     } catch (...) {
25224       {
25225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25226       };
25227     }
25228   }
25229 }
25230
25231
25232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25233   void * jresult ;
25234   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25235   Dali::FrameBufferImage result;
25236
25237   arg1 = (Dali::RenderTask *)jarg1;
25238   {
25239     try {
25240       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25241     } catch (std::out_of_range& e) {
25242       {
25243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25244       };
25245     } catch (std::exception& e) {
25246       {
25247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25248       };
25249     } catch (...) {
25250       {
25251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25252       };
25253     }
25254   }
25255   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25256   return jresult;
25257 }
25258
25259
25260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25261   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25262   Dali::FrameBuffer arg2 ;
25263   Dali::FrameBuffer *argp2 ;
25264
25265   arg1 = (Dali::RenderTask *)jarg1;
25266   argp2 = (Dali::FrameBuffer *)jarg2;
25267   if (!argp2) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25269     return ;
25270   }
25271   arg2 = *argp2;
25272   {
25273     try {
25274       (arg1)->SetFrameBuffer(arg2);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25293   void * jresult ;
25294   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25295   Dali::FrameBuffer result;
25296
25297   arg1 = (Dali::RenderTask *)jarg1;
25298   {
25299     try {
25300       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (...) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25312       };
25313     }
25314   }
25315   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25316   return jresult;
25317 }
25318
25319
25320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25321   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25322   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25323
25324   arg1 = (Dali::RenderTask *)jarg1;
25325   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25326   {
25327     try {
25328       (arg1)->SetScreenToFrameBufferFunction(arg2);
25329     } catch (std::out_of_range& e) {
25330       {
25331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25332       };
25333     } catch (std::exception& e) {
25334       {
25335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25336       };
25337     } catch (...) {
25338       {
25339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25340       };
25341     }
25342   }
25343 }
25344
25345
25346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25347   void * jresult ;
25348   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25349   Dali::RenderTask::ScreenToFrameBufferFunction result;
25350
25351   arg1 = (Dali::RenderTask *)jarg1;
25352   {
25353     try {
25354       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25355     } catch (std::out_of_range& e) {
25356       {
25357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25358       };
25359     } catch (std::exception& e) {
25360       {
25361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25362       };
25363     } catch (...) {
25364       {
25365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25366       };
25367     }
25368   }
25369   jresult = (void *)result;
25370   return jresult;
25371 }
25372
25373
25374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25376   Dali::Actor arg2 ;
25377   Dali::Actor *argp2 ;
25378
25379   arg1 = (Dali::RenderTask *)jarg1;
25380   argp2 = (Dali::Actor *)jarg2;
25381   if (!argp2) {
25382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25383     return ;
25384   }
25385   arg2 = *argp2;
25386   {
25387     try {
25388       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25389     } catch (std::out_of_range& e) {
25390       {
25391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25392       };
25393     } catch (std::exception& e) {
25394       {
25395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25396       };
25397     } catch (...) {
25398       {
25399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25400       };
25401     }
25402   }
25403 }
25404
25405
25406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25407   void * jresult ;
25408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25409   Dali::Actor result;
25410
25411   arg1 = (Dali::RenderTask *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429   jresult = new Dali::Actor((const Dali::Actor &)result);
25430   return jresult;
25431 }
25432
25433
25434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25436   Dali::Vector2 arg2 ;
25437   Dali::Vector2 *argp2 ;
25438
25439   arg1 = (Dali::RenderTask *)jarg1;
25440   argp2 = (Dali::Vector2 *)jarg2;
25441   if (!argp2) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25443     return ;
25444   }
25445   arg2 = *argp2;
25446   {
25447     try {
25448       (arg1)->SetViewportPosition(arg2);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25456       };
25457     } catch (...) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25460       };
25461     }
25462   }
25463 }
25464
25465
25466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25467   void * jresult ;
25468   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25469   Dali::Vector2 result;
25470
25471   arg1 = (Dali::RenderTask *)jarg1;
25472   {
25473     try {
25474       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25475     } catch (std::out_of_range& e) {
25476       {
25477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (std::exception& e) {
25480       {
25481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25495   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25496   Dali::Vector2 arg2 ;
25497   Dali::Vector2 *argp2 ;
25498
25499   arg1 = (Dali::RenderTask *)jarg1;
25500   argp2 = (Dali::Vector2 *)jarg2;
25501   if (!argp2) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25503     return ;
25504   }
25505   arg2 = *argp2;
25506   {
25507     try {
25508       (arg1)->SetViewportSize(arg2);
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (...) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25520       };
25521     }
25522   }
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25527   void * jresult ;
25528   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25529   Dali::Vector2 result;
25530
25531   arg1 = (Dali::RenderTask *)jarg1;
25532   {
25533     try {
25534       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (...) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25546       };
25547     }
25548   }
25549   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25550   return jresult;
25551 }
25552
25553
25554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25555   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25556   Dali::Viewport arg2 ;
25557   Dali::Viewport *argp2 ;
25558
25559   arg1 = (Dali::RenderTask *)jarg1;
25560   argp2 = (Dali::Viewport *)jarg2;
25561   if (!argp2) {
25562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25563     return ;
25564   }
25565   arg2 = *argp2;
25566   {
25567     try {
25568       (arg1)->SetViewport(arg2);
25569     } catch (std::out_of_range& e) {
25570       {
25571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25572       };
25573     } catch (std::exception& e) {
25574       {
25575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25580       };
25581     }
25582   }
25583 }
25584
25585
25586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25587   void * jresult ;
25588   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25589   Dali::Viewport result;
25590
25591   arg1 = (Dali::RenderTask *)jarg1;
25592   {
25593     try {
25594       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25595     } catch (std::out_of_range& e) {
25596       {
25597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25598       };
25599     } catch (std::exception& e) {
25600       {
25601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25602       };
25603     } catch (...) {
25604       {
25605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25606       };
25607     }
25608   }
25609   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25610   return jresult;
25611 }
25612
25613
25614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25615   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25616   Dali::Vector4 *arg2 = 0 ;
25617
25618   arg1 = (Dali::RenderTask *)jarg1;
25619   arg2 = (Dali::Vector4 *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25622     return ;
25623   }
25624   {
25625     try {
25626       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25638       };
25639     }
25640   }
25641 }
25642
25643
25644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25645   void * jresult ;
25646   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25647   Dali::Vector4 result;
25648
25649   arg1 = (Dali::RenderTask *)jarg1;
25650   {
25651     try {
25652       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25653     } catch (std::out_of_range& e) {
25654       {
25655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25656       };
25657     } catch (std::exception& e) {
25658       {
25659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25660       };
25661     } catch (...) {
25662       {
25663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25664       };
25665     }
25666   }
25667   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25668   return jresult;
25669 }
25670
25671
25672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25674   bool arg2 ;
25675
25676   arg1 = (Dali::RenderTask *)jarg1;
25677   arg2 = jarg2 ? true : false;
25678   {
25679     try {
25680       (arg1)->SetClearEnabled(arg2);
25681     } catch (std::out_of_range& e) {
25682       {
25683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25684       };
25685     } catch (std::exception& e) {
25686       {
25687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25692       };
25693     }
25694   }
25695 }
25696
25697
25698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25699   unsigned int jresult ;
25700   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25701   bool result;
25702
25703   arg1 = (Dali::RenderTask *)jarg1;
25704   {
25705     try {
25706       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25714       };
25715     } catch (...) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25718       };
25719     }
25720   }
25721   jresult = result;
25722   return jresult;
25723 }
25724
25725
25726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25727   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25728   bool arg2 ;
25729
25730   arg1 = (Dali::RenderTask *)jarg1;
25731   arg2 = jarg2 ? true : false;
25732   {
25733     try {
25734       (arg1)->SetCullMode(arg2);
25735     } catch (std::out_of_range& e) {
25736       {
25737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25738       };
25739     } catch (std::exception& e) {
25740       {
25741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25746       };
25747     }
25748   }
25749 }
25750
25751
25752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25753   unsigned int jresult ;
25754   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25755   bool result;
25756
25757   arg1 = (Dali::RenderTask *)jarg1;
25758   {
25759     try {
25760       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25761     } catch (std::out_of_range& e) {
25762       {
25763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25764       };
25765     } catch (std::exception& e) {
25766       {
25767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25768       };
25769     } catch (...) {
25770       {
25771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25772       };
25773     }
25774   }
25775   jresult = result;
25776   return jresult;
25777 }
25778
25779
25780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25782   unsigned int arg2 ;
25783
25784   arg1 = (Dali::RenderTask *)jarg1;
25785   arg2 = (unsigned int)jarg2;
25786   {
25787     try {
25788       (arg1)->SetRefreshRate(arg2);
25789     } catch (std::out_of_range& e) {
25790       {
25791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25792       };
25793     } catch (std::exception& e) {
25794       {
25795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25796       };
25797     } catch (...) {
25798       {
25799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25800       };
25801     }
25802   }
25803 }
25804
25805
25806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25807   unsigned int jresult ;
25808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25809   unsigned int result;
25810
25811   arg1 = (Dali::RenderTask *)jarg1;
25812   {
25813     try {
25814       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829   jresult = result;
25830   return jresult;
25831 }
25832
25833
25834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25835   unsigned int jresult ;
25836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25837   Dali::Vector3 *arg2 = 0 ;
25838   float *arg3 = 0 ;
25839   float *arg4 = 0 ;
25840   bool result;
25841
25842   arg1 = (Dali::RenderTask *)jarg1;
25843   arg2 = (Dali::Vector3 *)jarg2;
25844   if (!arg2) {
25845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25846     return 0;
25847   }
25848   arg3 = (float *)jarg3;
25849   arg4 = (float *)jarg4;
25850   {
25851     try {
25852       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (...) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25864       };
25865     }
25866   }
25867   jresult = result;
25868   return jresult;
25869 }
25870
25871
25872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25873   unsigned int jresult ;
25874   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25875   Dali::Actor arg2 ;
25876   float arg3 ;
25877   float arg4 ;
25878   float *arg5 = 0 ;
25879   float *arg6 = 0 ;
25880   Dali::Actor *argp2 ;
25881   bool result;
25882
25883   arg1 = (Dali::RenderTask *)jarg1;
25884   argp2 = (Dali::Actor *)jarg2;
25885   if (!argp2) {
25886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25887     return 0;
25888   }
25889   arg2 = *argp2;
25890   arg3 = (float)jarg3;
25891   arg4 = (float)jarg4;
25892   arg5 = (float *)jarg5;
25893   arg6 = (float *)jarg6;
25894   {
25895     try {
25896       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911   jresult = result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25917   void * jresult ;
25918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25919   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25920
25921   arg1 = (Dali::RenderTask *)jarg1;
25922   {
25923     try {
25924       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25925     } catch (std::out_of_range& e) {
25926       {
25927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25928       };
25929     } catch (std::exception& e) {
25930       {
25931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25932       };
25933     } catch (...) {
25934       {
25935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25936       };
25937     }
25938   }
25939   jresult = (void *)result;
25940   return jresult;
25941 }
25942
25943
25944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25945   void * jresult ;
25946   int arg1 ;
25947   Dali::TouchPoint::State arg2 ;
25948   float arg3 ;
25949   float arg4 ;
25950   Dali::TouchPoint *result = 0 ;
25951
25952   arg1 = (int)jarg1;
25953   arg2 = (Dali::TouchPoint::State)jarg2;
25954   arg3 = (float)jarg3;
25955   arg4 = (float)jarg4;
25956   {
25957     try {
25958       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25959     } catch (std::out_of_range& e) {
25960       {
25961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (std::exception& e) {
25964       {
25965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973   jresult = (void *)result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25979   void * jresult ;
25980   int arg1 ;
25981   Dali::TouchPoint::State arg2 ;
25982   float arg3 ;
25983   float arg4 ;
25984   float arg5 ;
25985   float arg6 ;
25986   Dali::TouchPoint *result = 0 ;
25987
25988   arg1 = (int)jarg1;
25989   arg2 = (Dali::TouchPoint::State)jarg2;
25990   arg3 = (float)jarg3;
25991   arg4 = (float)jarg4;
25992   arg5 = (float)jarg5;
25993   arg6 = (float)jarg6;
25994   {
25995     try {
25996       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26004       };
26005     } catch (...) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26008       };
26009     }
26010   }
26011   jresult = (void *)result;
26012   return jresult;
26013 }
26014
26015
26016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018
26019   arg1 = (Dali::TouchPoint *)jarg1;
26020   {
26021     try {
26022       delete arg1;
26023     } catch (std::out_of_range& e) {
26024       {
26025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26026       };
26027     } catch (std::exception& e) {
26028       {
26029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26030       };
26031     } catch (...) {
26032       {
26033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26034       };
26035     }
26036   }
26037 }
26038
26039
26040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26041   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26042   int arg2 ;
26043
26044   arg1 = (Dali::TouchPoint *)jarg1;
26045   arg2 = (int)jarg2;
26046   if (arg1) (arg1)->deviceId = arg2;
26047 }
26048
26049
26050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26051   int jresult ;
26052   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26053   int result;
26054
26055   arg1 = (Dali::TouchPoint *)jarg1;
26056   result = (int) ((arg1)->deviceId);
26057   jresult = result;
26058   return jresult;
26059 }
26060
26061
26062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26063   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26064   Dali::TouchPoint::State arg2 ;
26065
26066   arg1 = (Dali::TouchPoint *)jarg1;
26067   arg2 = (Dali::TouchPoint::State)jarg2;
26068   if (arg1) (arg1)->state = arg2;
26069 }
26070
26071
26072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26073   int jresult ;
26074   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26075   Dali::TouchPoint::State result;
26076
26077   arg1 = (Dali::TouchPoint *)jarg1;
26078   result = (Dali::TouchPoint::State) ((arg1)->state);
26079   jresult = (int)result;
26080   return jresult;
26081 }
26082
26083
26084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26085   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26086   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26087
26088   arg1 = (Dali::TouchPoint *)jarg1;
26089   arg2 = (Dali::Actor *)jarg2;
26090   if (arg1) (arg1)->hitActor = *arg2;
26091 }
26092
26093
26094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26095   void * jresult ;
26096   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26097   Dali::Actor *result = 0 ;
26098
26099   arg1 = (Dali::TouchPoint *)jarg1;
26100   result = (Dali::Actor *)& ((arg1)->hitActor);
26101   jresult = (void *)result;
26102   return jresult;
26103 }
26104
26105
26106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26107   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26108   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26109
26110   arg1 = (Dali::TouchPoint *)jarg1;
26111   arg2 = (Dali::Vector2 *)jarg2;
26112   if (arg1) (arg1)->local = *arg2;
26113 }
26114
26115
26116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26117   void * jresult ;
26118   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26119   Dali::Vector2 *result = 0 ;
26120
26121   arg1 = (Dali::TouchPoint *)jarg1;
26122   result = (Dali::Vector2 *)& ((arg1)->local);
26123   jresult = (void *)result;
26124   return jresult;
26125 }
26126
26127
26128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26129   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26130   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26131
26132   arg1 = (Dali::TouchPoint *)jarg1;
26133   arg2 = (Dali::Vector2 *)jarg2;
26134   if (arg1) (arg1)->screen = *arg2;
26135 }
26136
26137
26138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26139   void * jresult ;
26140   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26141   Dali::Vector2 *result = 0 ;
26142
26143   arg1 = (Dali::TouchPoint *)jarg1;
26144   result = (Dali::Vector2 *)& ((arg1)->screen);
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26151   void * jresult ;
26152   Dali::TouchData *result = 0 ;
26153
26154   {
26155     try {
26156       result = (Dali::TouchData *)new Dali::TouchData();
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26164       };
26165     } catch (...) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26168       };
26169     }
26170   }
26171   jresult = (void *)result;
26172   return jresult;
26173 }
26174
26175
26176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26177   void * jresult ;
26178   Dali::TouchData *arg1 = 0 ;
26179   Dali::TouchData *result = 0 ;
26180
26181   arg1 = (Dali::TouchData *)jarg1;
26182   if (!arg1) {
26183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26184     return 0;
26185   }
26186   {
26187     try {
26188       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26189     } catch (std::out_of_range& e) {
26190       {
26191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26192       };
26193     } catch (std::exception& e) {
26194       {
26195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26196       };
26197     } catch (...) {
26198       {
26199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26200       };
26201     }
26202   }
26203   jresult = (void *)result;
26204   return jresult;
26205 }
26206
26207
26208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26209   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26210
26211   arg1 = (Dali::TouchData *)jarg1;
26212   {
26213     try {
26214       delete arg1;
26215     } catch (std::out_of_range& e) {
26216       {
26217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26218       };
26219     } catch (std::exception& e) {
26220       {
26221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26222       };
26223     } catch (...) {
26224       {
26225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26226       };
26227     }
26228   }
26229 }
26230
26231
26232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26233   void * jresult ;
26234   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26235   Dali::TouchData *arg2 = 0 ;
26236   Dali::TouchData *result = 0 ;
26237
26238   arg1 = (Dali::TouchData *)jarg1;
26239   arg2 = (Dali::TouchData *)jarg2;
26240   if (!arg2) {
26241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26242     return 0;
26243   }
26244   {
26245     try {
26246       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26247     } catch (std::out_of_range& e) {
26248       {
26249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26250       };
26251     } catch (std::exception& e) {
26252       {
26253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (...) {
26256       {
26257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26258       };
26259     }
26260   }
26261   jresult = (void *)result;
26262   return jresult;
26263 }
26264
26265
26266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26267   unsigned long jresult ;
26268   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26269   unsigned long result;
26270
26271   arg1 = (Dali::TouchData *)jarg1;
26272   {
26273     try {
26274       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289   jresult = (unsigned long)result;
26290   return jresult;
26291 }
26292
26293
26294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26295   unsigned long jresult ;
26296   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26297   std::size_t result;
26298
26299   arg1 = (Dali::TouchData *)jarg1;
26300   {
26301     try {
26302       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26303     } catch (std::out_of_range& e) {
26304       {
26305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26306       };
26307     } catch (std::exception& e) {
26308       {
26309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26310       };
26311     } catch (...) {
26312       {
26313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26314       };
26315     }
26316   }
26317   jresult = (unsigned long)result;
26318   return jresult;
26319 }
26320
26321
26322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26323   int jresult ;
26324   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26325   std::size_t arg2 ;
26326   int32_t result;
26327
26328   arg1 = (Dali::TouchData *)jarg1;
26329   arg2 = (std::size_t)jarg2;
26330   {
26331     try {
26332       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26333     } catch (std::out_of_range& e) {
26334       {
26335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (std::exception& e) {
26338       {
26339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347   jresult = result;
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26353   int jresult ;
26354   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26355   std::size_t arg2 ;
26356   Dali::PointState::Type result;
26357
26358   arg1 = (Dali::TouchData *)jarg1;
26359   arg2 = (std::size_t)jarg2;
26360   {
26361     try {
26362       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377   jresult = (int)result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26383   void * jresult ;
26384   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26385   std::size_t arg2 ;
26386   Dali::Actor result;
26387
26388   arg1 = (Dali::TouchData *)jarg1;
26389   arg2 = (std::size_t)jarg2;
26390   {
26391     try {
26392       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26400       };
26401     } catch (...) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26404       };
26405     }
26406   }
26407   jresult = new Dali::Actor((const Dali::Actor &)result);
26408   return jresult;
26409 }
26410
26411
26412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26413   void * jresult ;
26414   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26415   std::size_t arg2 ;
26416   Dali::Vector2 *result = 0 ;
26417
26418   arg1 = (Dali::TouchData *)jarg1;
26419   arg2 = (std::size_t)jarg2;
26420   {
26421     try {
26422       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26423     } catch (std::out_of_range& e) {
26424       {
26425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26426       };
26427     } catch (std::exception& e) {
26428       {
26429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26430       };
26431     } catch (...) {
26432       {
26433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26434       };
26435     }
26436   }
26437   jresult = (void *)result;
26438   return jresult;
26439 }
26440
26441
26442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26443   void * jresult ;
26444   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26445   std::size_t arg2 ;
26446   Dali::Vector2 *result = 0 ;
26447
26448   arg1 = (Dali::TouchData *)jarg1;
26449   arg2 = (std::size_t)jarg2;
26450   {
26451     try {
26452       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26453     } catch (std::out_of_range& e) {
26454       {
26455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26456       };
26457     } catch (std::exception& e) {
26458       {
26459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26460       };
26461     } catch (...) {
26462       {
26463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26464       };
26465     }
26466   }
26467   jresult = (void *)result;
26468   return jresult;
26469 }
26470
26471
26472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26473   float jresult ;
26474   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26475   std::size_t arg2 ;
26476   float result;
26477
26478   arg1 = (Dali::TouchData *)jarg1;
26479   arg2 = (std::size_t)jarg2;
26480   {
26481     try {
26482       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26483     } catch (std::out_of_range& e) {
26484       {
26485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26486       };
26487     } catch (std::exception& e) {
26488       {
26489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26490       };
26491     } catch (...) {
26492       {
26493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26494       };
26495     }
26496   }
26497   jresult = result;
26498   return jresult;
26499 }
26500
26501
26502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26503   void * jresult ;
26504   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26505   std::size_t arg2 ;
26506   Dali::Vector2 *result = 0 ;
26507
26508   arg1 = (Dali::TouchData *)jarg1;
26509   arg2 = (std::size_t)jarg2;
26510   {
26511     try {
26512       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26513     } catch (std::out_of_range& e) {
26514       {
26515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26516       };
26517     } catch (std::exception& e) {
26518       {
26519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26520       };
26521     } catch (...) {
26522       {
26523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26524       };
26525     }
26526   }
26527   jresult = (void *)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26533   float jresult ;
26534   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26535   std::size_t arg2 ;
26536   float result;
26537
26538   arg1 = (Dali::TouchData *)jarg1;
26539   arg2 = (std::size_t)jarg2;
26540   {
26541     try {
26542       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26543     } catch (std::out_of_range& e) {
26544       {
26545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26546       };
26547     } catch (std::exception& e) {
26548       {
26549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26550       };
26551     } catch (...) {
26552       {
26553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26554       };
26555     }
26556   }
26557   jresult = result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26563   void * jresult ;
26564   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26565   std::size_t arg2 ;
26566   Dali::Degree result;
26567
26568   arg1 = (Dali::TouchData *)jarg1;
26569   arg2 = (std::size_t)jarg2;
26570   {
26571     try {
26572       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26573     } catch (std::out_of_range& e) {
26574       {
26575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26576       };
26577     } catch (std::exception& e) {
26578       {
26579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (...) {
26582       {
26583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26584       };
26585     }
26586   }
26587   jresult = new Dali::Degree((const Dali::Degree &)result);
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26593   void * jresult ;
26594   Dali::GestureDetector *result = 0 ;
26595
26596   {
26597     try {
26598       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26599     } catch (std::out_of_range& e) {
26600       {
26601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26602       };
26603     } catch (std::exception& e) {
26604       {
26605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26606       };
26607     } catch (...) {
26608       {
26609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26610       };
26611     }
26612   }
26613   jresult = (void *)result;
26614   return jresult;
26615 }
26616
26617
26618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26619   void * jresult ;
26620   Dali::BaseHandle arg1 ;
26621   Dali::BaseHandle *argp1 ;
26622   Dali::GestureDetector result;
26623
26624   argp1 = (Dali::BaseHandle *)jarg1;
26625   if (!argp1) {
26626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26627     return 0;
26628   }
26629   arg1 = *argp1;
26630   {
26631     try {
26632       result = Dali::GestureDetector::DownCast(arg1);
26633     } catch (std::out_of_range& e) {
26634       {
26635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26636       };
26637     } catch (std::exception& e) {
26638       {
26639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26640       };
26641     } catch (...) {
26642       {
26643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26644       };
26645     }
26646   }
26647   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26653   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26654
26655   arg1 = (Dali::GestureDetector *)jarg1;
26656   {
26657     try {
26658       delete arg1;
26659     } catch (std::out_of_range& e) {
26660       {
26661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26662       };
26663     } catch (std::exception& e) {
26664       {
26665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26666       };
26667     } catch (...) {
26668       {
26669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26670       };
26671     }
26672   }
26673 }
26674
26675
26676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26677   void * jresult ;
26678   Dali::GestureDetector *arg1 = 0 ;
26679   Dali::GestureDetector *result = 0 ;
26680
26681   arg1 = (Dali::GestureDetector *)jarg1;
26682   if (!arg1) {
26683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26684     return 0;
26685   }
26686   {
26687     try {
26688       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26700       };
26701     }
26702   }
26703   jresult = (void *)result;
26704   return jresult;
26705 }
26706
26707
26708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26709   void * jresult ;
26710   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26711   Dali::GestureDetector *arg2 = 0 ;
26712   Dali::GestureDetector *result = 0 ;
26713
26714   arg1 = (Dali::GestureDetector *)jarg1;
26715   arg2 = (Dali::GestureDetector *)jarg2;
26716   if (!arg2) {
26717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26718     return 0;
26719   }
26720   {
26721     try {
26722       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26723     } catch (std::out_of_range& e) {
26724       {
26725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26726       };
26727     } catch (std::exception& e) {
26728       {
26729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26730       };
26731     } catch (...) {
26732       {
26733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26734       };
26735     }
26736   }
26737   jresult = (void *)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26743   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26744   Dali::Actor arg2 ;
26745   Dali::Actor *argp2 ;
26746
26747   arg1 = (Dali::GestureDetector *)jarg1;
26748   argp2 = (Dali::Actor *)jarg2;
26749   if (!argp2) {
26750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26751     return ;
26752   }
26753   arg2 = *argp2;
26754   {
26755     try {
26756       (arg1)->Attach(arg2);
26757     } catch (std::out_of_range& e) {
26758       {
26759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26760       };
26761     } catch (std::exception& e) {
26762       {
26763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26764       };
26765     } catch (...) {
26766       {
26767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26768       };
26769     }
26770   }
26771 }
26772
26773
26774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26775   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26776   Dali::Actor arg2 ;
26777   Dali::Actor *argp2 ;
26778
26779   arg1 = (Dali::GestureDetector *)jarg1;
26780   argp2 = (Dali::Actor *)jarg2;
26781   if (!argp2) {
26782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26783     return ;
26784   }
26785   arg2 = *argp2;
26786   {
26787     try {
26788       (arg1)->Detach(arg2);
26789     } catch (std::out_of_range& e) {
26790       {
26791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26792       };
26793     } catch (std::exception& e) {
26794       {
26795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (...) {
26798       {
26799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26800       };
26801     }
26802   }
26803 }
26804
26805
26806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26807   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26808
26809   arg1 = (Dali::GestureDetector *)jarg1;
26810   {
26811     try {
26812       (arg1)->DetachAll();
26813     } catch (std::out_of_range& e) {
26814       {
26815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (std::exception& e) {
26818       {
26819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827 }
26828
26829
26830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26831   unsigned long jresult ;
26832   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26833   size_t result;
26834
26835   arg1 = (Dali::GestureDetector *)jarg1;
26836   {
26837     try {
26838       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26846       };
26847     } catch (...) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26850       };
26851     }
26852   }
26853   jresult = (unsigned long)result;
26854   return jresult;
26855 }
26856
26857
26858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26859   void * jresult ;
26860   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26861   size_t arg2 ;
26862   Dali::Actor result;
26863
26864   arg1 = (Dali::GestureDetector *)jarg1;
26865   arg2 = (size_t)jarg2;
26866   {
26867     try {
26868       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26869     } catch (std::out_of_range& e) {
26870       {
26871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26872       };
26873     } catch (std::exception& e) {
26874       {
26875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26876       };
26877     } catch (...) {
26878       {
26879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26880       };
26881     }
26882   }
26883   jresult = new Dali::Actor((const Dali::Actor &)result);
26884   return jresult;
26885 }
26886
26887
26888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26889   void * jresult ;
26890   Dali::Gesture *arg1 = 0 ;
26891   Dali::Gesture *result = 0 ;
26892
26893   arg1 = (Dali::Gesture *)jarg1;
26894   if (!arg1) {
26895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26896     return 0;
26897   }
26898   {
26899     try {
26900       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26901     } catch (std::out_of_range& e) {
26902       {
26903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (std::exception& e) {
26906       {
26907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26908       };
26909     } catch (...) {
26910       {
26911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26912       };
26913     }
26914   }
26915   jresult = (void *)result;
26916   return jresult;
26917 }
26918
26919
26920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26921   void * jresult ;
26922   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26923   Dali::Gesture *arg2 = 0 ;
26924   Dali::Gesture *result = 0 ;
26925
26926   arg1 = (Dali::Gesture *)jarg1;
26927   arg2 = (Dali::Gesture *)jarg2;
26928   if (!arg2) {
26929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26930     return 0;
26931   }
26932   {
26933     try {
26934       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26935     } catch (std::out_of_range& e) {
26936       {
26937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26938       };
26939     } catch (std::exception& e) {
26940       {
26941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26942       };
26943     } catch (...) {
26944       {
26945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26946       };
26947     }
26948   }
26949   jresult = (void *)result;
26950   return jresult;
26951 }
26952
26953
26954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26955   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26956
26957   arg1 = (Dali::Gesture *)jarg1;
26958   {
26959     try {
26960       delete arg1;
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (...) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26972       };
26973     }
26974   }
26975 }
26976
26977
26978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26979   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26980   Dali::Gesture::Type arg2 ;
26981
26982   arg1 = (Dali::Gesture *)jarg1;
26983   arg2 = (Dali::Gesture::Type)jarg2;
26984   if (arg1) (arg1)->type = arg2;
26985 }
26986
26987
26988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26989   int jresult ;
26990   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26991   Dali::Gesture::Type result;
26992
26993   arg1 = (Dali::Gesture *)jarg1;
26994   result = (Dali::Gesture::Type) ((arg1)->type);
26995   jresult = (int)result;
26996   return jresult;
26997 }
26998
26999
27000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
27001   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27002   Dali::Gesture::State arg2 ;
27003
27004   arg1 = (Dali::Gesture *)jarg1;
27005   arg2 = (Dali::Gesture::State)jarg2;
27006   if (arg1) (arg1)->state = arg2;
27007 }
27008
27009
27010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27011   int jresult ;
27012   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27013   Dali::Gesture::State result;
27014
27015   arg1 = (Dali::Gesture *)jarg1;
27016   result = (Dali::Gesture::State) ((arg1)->state);
27017   jresult = (int)result;
27018   return jresult;
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27023   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27024   unsigned int arg2 ;
27025
27026   arg1 = (Dali::Gesture *)jarg1;
27027   arg2 = (unsigned int)jarg2;
27028   if (arg1) (arg1)->time = arg2;
27029 }
27030
27031
27032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27033   unsigned int jresult ;
27034   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27035   unsigned int result;
27036
27037   arg1 = (Dali::Gesture *)jarg1;
27038   result = (unsigned int) ((arg1)->time);
27039   jresult = result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27045   void * jresult ;
27046   Dali::HoverEvent *result = 0 ;
27047
27048   {
27049     try {
27050       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27051     } catch (std::out_of_range& e) {
27052       {
27053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27054       };
27055     } catch (std::exception& e) {
27056       {
27057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27058       };
27059     } catch (...) {
27060       {
27061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27062       };
27063     }
27064   }
27065   jresult = (void *)result;
27066   return jresult;
27067 }
27068
27069
27070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27071   void * jresult ;
27072   unsigned long arg1 ;
27073   Dali::HoverEvent *result = 0 ;
27074
27075   arg1 = (unsigned long)jarg1;
27076   {
27077     try {
27078       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27079     } catch (std::out_of_range& e) {
27080       {
27081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (std::exception& e) {
27084       {
27085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27086       };
27087     } catch (...) {
27088       {
27089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27090       };
27091     }
27092   }
27093   jresult = (void *)result;
27094   return jresult;
27095 }
27096
27097
27098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27099   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27100
27101   arg1 = (Dali::HoverEvent *)jarg1;
27102   {
27103     try {
27104       delete arg1;
27105     } catch (std::out_of_range& e) {
27106       {
27107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27108       };
27109     } catch (std::exception& e) {
27110       {
27111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27112       };
27113     } catch (...) {
27114       {
27115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27116       };
27117     }
27118   }
27119 }
27120
27121
27122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27123   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27124   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27125
27126   arg1 = (Dali::HoverEvent *)jarg1;
27127   arg2 = (Dali::TouchPointContainer *)jarg2;
27128   if (arg1) (arg1)->points = *arg2;
27129 }
27130
27131
27132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27133   void * jresult ;
27134   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27135   Dali::TouchPointContainer *result = 0 ;
27136
27137   arg1 = (Dali::HoverEvent *)jarg1;
27138   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27139   jresult = (void *)result;
27140   return jresult;
27141 }
27142
27143
27144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27146   unsigned long arg2 ;
27147
27148   arg1 = (Dali::HoverEvent *)jarg1;
27149   arg2 = (unsigned long)jarg2;
27150   if (arg1) (arg1)->time = arg2;
27151 }
27152
27153
27154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27155   unsigned long jresult ;
27156   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27157   unsigned long result;
27158
27159   arg1 = (Dali::HoverEvent *)jarg1;
27160   result = (unsigned long) ((arg1)->time);
27161   jresult = (unsigned long)result;
27162   return jresult;
27163 }
27164
27165
27166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27167   unsigned int jresult ;
27168   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27169   unsigned int result;
27170
27171   arg1 = (Dali::HoverEvent *)jarg1;
27172   {
27173     try {
27174       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27175     } catch (std::out_of_range& e) {
27176       {
27177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27178       };
27179     } catch (std::exception& e) {
27180       {
27181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27182       };
27183     } catch (...) {
27184       {
27185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27186       };
27187     }
27188   }
27189   jresult = result;
27190   return jresult;
27191 }
27192
27193
27194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27195   void * jresult ;
27196   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27197   unsigned int arg2 ;
27198   Dali::TouchPoint *result = 0 ;
27199
27200   arg1 = (Dali::HoverEvent *)jarg1;
27201   arg2 = (unsigned int)jarg2;
27202   {
27203     try {
27204       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27205     } catch (std::out_of_range& e) {
27206       {
27207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27208       };
27209     } catch (std::exception& e) {
27210       {
27211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27212       };
27213     } catch (...) {
27214       {
27215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27216       };
27217     }
27218   }
27219   jresult = (void *)result;
27220   return jresult;
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27225   void * jresult ;
27226   Dali::KeyEvent *result = 0 ;
27227
27228   {
27229     try {
27230       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27242       };
27243     }
27244   }
27245   jresult = (void *)result;
27246   return jresult;
27247 }
27248
27249
27250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27251   void * jresult ;
27252   std::string *arg1 = 0 ;
27253   std::string *arg2 = 0 ;
27254   int arg3 ;
27255   int arg4 ;
27256   unsigned long arg5 ;
27257   Dali::KeyEvent::State *arg6 = 0 ;
27258   Dali::KeyEvent::State temp6 ;
27259   Dali::KeyEvent *result = 0 ;
27260
27261   if (!jarg1) {
27262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27263     return 0;
27264   }
27265   std::string arg1_str(jarg1);
27266   arg1 = &arg1_str;
27267   if (!jarg2) {
27268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27269     return 0;
27270   }
27271   std::string arg2_str(jarg2);
27272   arg2 = &arg2_str;
27273   arg3 = (int)jarg3;
27274   arg4 = (int)jarg4;
27275   arg5 = (unsigned long)jarg5;
27276   temp6 = (Dali::KeyEvent::State)jarg6;
27277   arg6 = &temp6;
27278   {
27279     try {
27280       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27281     } catch (std::out_of_range& e) {
27282       {
27283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27284       };
27285     } catch (std::exception& e) {
27286       {
27287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27288       };
27289     } catch (...) {
27290       {
27291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27292       };
27293     }
27294   }
27295   jresult = (void *)result;
27296
27297   //argout typemap for const std::string&
27298
27299
27300   //argout typemap for const std::string&
27301
27302   return jresult;
27303 }
27304
27305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27306   void * jresult ;
27307   Dali::KeyEvent *arg1 = 0 ;
27308   Dali::KeyEvent *result = 0 ;
27309
27310   arg1 = (Dali::KeyEvent *)jarg1;
27311   if (!arg1) {
27312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27313     return 0;
27314   }
27315   {
27316     try {
27317       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27318     } catch (std::out_of_range& e) {
27319       {
27320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (std::exception& e) {
27323       {
27324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332   jresult = (void *)result;
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27338   void * jresult ;
27339   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27340   Dali::KeyEvent *arg2 = 0 ;
27341   Dali::KeyEvent *result = 0 ;
27342
27343   arg1 = (Dali::KeyEvent *)jarg1;
27344   arg2 = (Dali::KeyEvent *)jarg2;
27345   if (!arg2) {
27346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27347     return 0;
27348   }
27349   {
27350     try {
27351       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27352     } catch (std::out_of_range& e) {
27353       {
27354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (std::exception& e) {
27357       {
27358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (...) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27363       };
27364     }
27365   }
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27372   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27373
27374   arg1 = (Dali::KeyEvent *)jarg1;
27375   {
27376     try {
27377       delete arg1;
27378     } catch (std::out_of_range& e) {
27379       {
27380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27381       };
27382     } catch (std::exception& e) {
27383       {
27384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27385       };
27386     } catch (...) {
27387       {
27388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27389       };
27390     }
27391   }
27392 }
27393
27394
27395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27396   unsigned int jresult ;
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   bool result;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   {
27402     try {
27403       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27411       };
27412     } catch (...) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27415       };
27416     }
27417   }
27418   jresult = result;
27419   return jresult;
27420 }
27421
27422
27423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27424   unsigned int jresult ;
27425   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27426   bool result;
27427
27428   arg1 = (Dali::KeyEvent *)jarg1;
27429   {
27430     try {
27431       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27432     } catch (std::out_of_range& e) {
27433       {
27434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27435       };
27436     } catch (std::exception& e) {
27437       {
27438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27439       };
27440     } catch (...) {
27441       {
27442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27443       };
27444     }
27445   }
27446   jresult = result;
27447   return jresult;
27448 }
27449
27450
27451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27452   unsigned int jresult ;
27453   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27454   bool result;
27455
27456   arg1 = (Dali::KeyEvent *)jarg1;
27457   {
27458     try {
27459       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27460     } catch (std::out_of_range& e) {
27461       {
27462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (std::exception& e) {
27465       {
27466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474   jresult = result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27480   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27481   std::string *arg2 = 0 ;
27482
27483   arg1 = (Dali::KeyEvent *)jarg1;
27484   if (!jarg2) {
27485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27486     return ;
27487   }
27488   std::string arg2_str(jarg2);
27489   arg2 = &arg2_str;
27490   if (arg1) (arg1)->keyPressedName = *arg2;
27491
27492   //argout typemap for const std::string&
27493
27494 }
27495
27496
27497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27498   char * jresult ;
27499   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27500   std::string *result = 0 ;
27501
27502   arg1 = (Dali::KeyEvent *)jarg1;
27503   result = (std::string *) & ((arg1)->keyPressedName);
27504   jresult = SWIG_csharp_string_callback(result->c_str());
27505   return jresult;
27506 }
27507
27508
27509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27511   std::string *arg2 = 0 ;
27512
27513   arg1 = (Dali::KeyEvent *)jarg1;
27514   if (!jarg2) {
27515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27516     return ;
27517   }
27518   std::string arg2_str(jarg2);
27519   arg2 = &arg2_str;
27520   if (arg1) (arg1)->keyPressed = *arg2;
27521
27522   //argout typemap for const std::string&
27523
27524 }
27525
27526
27527 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27528   char * jresult ;
27529   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27530   std::string *result = 0 ;
27531
27532   arg1 = (Dali::KeyEvent *)jarg1;
27533   result = (std::string *) & ((arg1)->keyPressed);
27534   jresult = SWIG_csharp_string_callback(result->c_str());
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27540   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27541   int arg2 ;
27542
27543   arg1 = (Dali::KeyEvent *)jarg1;
27544   arg2 = (int)jarg2;
27545   if (arg1) (arg1)->keyCode = arg2;
27546 }
27547
27548
27549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27550   int jresult ;
27551   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27552   int result;
27553
27554   arg1 = (Dali::KeyEvent *)jarg1;
27555   result = (int) ((arg1)->keyCode);
27556   jresult = result;
27557   return jresult;
27558 }
27559
27560
27561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27562   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27563   int arg2 ;
27564
27565   arg1 = (Dali::KeyEvent *)jarg1;
27566   arg2 = (int)jarg2;
27567   if (arg1) (arg1)->keyModifier = arg2;
27568 }
27569
27570
27571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27572   int jresult ;
27573   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27574   int result;
27575
27576   arg1 = (Dali::KeyEvent *)jarg1;
27577   result = (int) ((arg1)->keyModifier);
27578   jresult = result;
27579   return jresult;
27580 }
27581
27582
27583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27584   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27585   unsigned long arg2 ;
27586
27587   arg1 = (Dali::KeyEvent *)jarg1;
27588   arg2 = (unsigned long)jarg2;
27589   if (arg1) (arg1)->time = arg2;
27590 }
27591
27592
27593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27594   unsigned long jresult ;
27595   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27596   unsigned long result;
27597
27598   arg1 = (Dali::KeyEvent *)jarg1;
27599   result = (unsigned long) ((arg1)->time);
27600   jresult = (unsigned long)result;
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27606   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27607   Dali::KeyEvent::State arg2 ;
27608
27609   arg1 = (Dali::KeyEvent *)jarg1;
27610   arg2 = (Dali::KeyEvent::State)jarg2;
27611   if (arg1) (arg1)->state = arg2;
27612 }
27613
27614
27615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27616   int jresult ;
27617   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27618   Dali::KeyEvent::State result;
27619
27620   arg1 = (Dali::KeyEvent *)jarg1;
27621   result = (Dali::KeyEvent::State) ((arg1)->state);
27622   jresult = (int)result;
27623   return jresult;
27624 }
27625
27626
27627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27628   void * jresult ;
27629   Dali::LongPressGestureDetector *result = 0 ;
27630
27631   {
27632     try {
27633       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27634     } catch (std::out_of_range& e) {
27635       {
27636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (std::exception& e) {
27639       {
27640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27645       };
27646     }
27647   }
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27654   void * jresult ;
27655   Dali::LongPressGestureDetector result;
27656
27657   {
27658     try {
27659       result = Dali::LongPressGestureDetector::New();
27660     } catch (std::out_of_range& e) {
27661       {
27662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27663       };
27664     } catch (std::exception& e) {
27665       {
27666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27667       };
27668     } catch (...) {
27669       {
27670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27671       };
27672     }
27673   }
27674   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27675   return jresult;
27676 }
27677
27678
27679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27680   void * jresult ;
27681   unsigned int arg1 ;
27682   Dali::LongPressGestureDetector result;
27683
27684   arg1 = (unsigned int)jarg1;
27685   {
27686     try {
27687       result = Dali::LongPressGestureDetector::New(arg1);
27688     } catch (std::out_of_range& e) {
27689       {
27690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27691       };
27692     } catch (std::exception& e) {
27693       {
27694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27695       };
27696     } catch (...) {
27697       {
27698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27699       };
27700     }
27701   }
27702   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27703   return jresult;
27704 }
27705
27706
27707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27708   void * jresult ;
27709   unsigned int arg1 ;
27710   unsigned int arg2 ;
27711   Dali::LongPressGestureDetector result;
27712
27713   arg1 = (unsigned int)jarg1;
27714   arg2 = (unsigned int)jarg2;
27715   {
27716     try {
27717       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27725       };
27726     } catch (...) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27729       };
27730     }
27731   }
27732   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27733   return jresult;
27734 }
27735
27736
27737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27738   void * jresult ;
27739   Dali::BaseHandle arg1 ;
27740   Dali::BaseHandle *argp1 ;
27741   Dali::LongPressGestureDetector result;
27742
27743   argp1 = (Dali::BaseHandle *)jarg1;
27744   if (!argp1) {
27745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27746     return 0;
27747   }
27748   arg1 = *argp1;
27749   {
27750     try {
27751       result = Dali::LongPressGestureDetector::DownCast(arg1);
27752     } catch (std::out_of_range& e) {
27753       {
27754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27755       };
27756     } catch (std::exception& e) {
27757       {
27758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (...) {
27761       {
27762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27763       };
27764     }
27765   }
27766   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27767   return jresult;
27768 }
27769
27770
27771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27772   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27773
27774   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27775   {
27776     try {
27777       delete arg1;
27778     } catch (std::out_of_range& e) {
27779       {
27780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27781       };
27782     } catch (std::exception& e) {
27783       {
27784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27785       };
27786     } catch (...) {
27787       {
27788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27789       };
27790     }
27791   }
27792 }
27793
27794
27795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27796   void * jresult ;
27797   Dali::LongPressGestureDetector *arg1 = 0 ;
27798   Dali::LongPressGestureDetector *result = 0 ;
27799
27800   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27801   if (!arg1) {
27802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27803     return 0;
27804   }
27805   {
27806     try {
27807       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27808     } catch (std::out_of_range& e) {
27809       {
27810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27811       };
27812     } catch (std::exception& e) {
27813       {
27814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27815       };
27816     } catch (...) {
27817       {
27818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27819       };
27820     }
27821   }
27822   jresult = (void *)result;
27823   return jresult;
27824 }
27825
27826
27827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27828   void * jresult ;
27829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27830   Dali::LongPressGestureDetector *arg2 = 0 ;
27831   Dali::LongPressGestureDetector *result = 0 ;
27832
27833   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27834   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27835   if (!arg2) {
27836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27837     return 0;
27838   }
27839   {
27840     try {
27841       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27849       };
27850     } catch (...) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27853       };
27854     }
27855   }
27856   jresult = (void *)result;
27857   return jresult;
27858 }
27859
27860
27861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27863   unsigned int arg2 ;
27864
27865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27866   arg2 = (unsigned int)jarg2;
27867   {
27868     try {
27869       (arg1)->SetTouchesRequired(arg2);
27870     } catch (std::out_of_range& e) {
27871       {
27872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27873       };
27874     } catch (std::exception& e) {
27875       {
27876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27877       };
27878     } catch (...) {
27879       {
27880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27881       };
27882     }
27883   }
27884 }
27885
27886
27887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27889   unsigned int arg2 ;
27890   unsigned int arg3 ;
27891
27892   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27893   arg2 = (unsigned int)jarg2;
27894   arg3 = (unsigned int)jarg3;
27895   {
27896     try {
27897       (arg1)->SetTouchesRequired(arg2,arg3);
27898     } catch (std::out_of_range& e) {
27899       {
27900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27901       };
27902     } catch (std::exception& e) {
27903       {
27904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27905       };
27906     } catch (...) {
27907       {
27908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27909       };
27910     }
27911   }
27912 }
27913
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27916   unsigned int jresult ;
27917   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27918   unsigned int result;
27919
27920   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27921   {
27922     try {
27923       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (...) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27935       };
27936     }
27937   }
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27944   unsigned int jresult ;
27945   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27946   unsigned int result;
27947
27948   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27949   {
27950     try {
27951       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27952     } catch (std::out_of_range& e) {
27953       {
27954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27955       };
27956     } catch (std::exception& e) {
27957       {
27958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (...) {
27961       {
27962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27963       };
27964     }
27965   }
27966   jresult = result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27972   void * jresult ;
27973   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27974   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27975
27976   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27977   {
27978     try {
27979       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27980     } catch (std::out_of_range& e) {
27981       {
27982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (std::exception& e) {
27985       {
27986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994   jresult = (void *)result;
27995   return jresult;
27996 }
27997
27998
27999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
28000   void * jresult ;
28001   Dali::Gesture::State arg1 ;
28002   Dali::LongPressGesture *result = 0 ;
28003
28004   arg1 = (Dali::Gesture::State)jarg1;
28005   {
28006     try {
28007       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28008     } catch (std::out_of_range& e) {
28009       {
28010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28011       };
28012     } catch (std::exception& e) {
28013       {
28014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28015       };
28016     } catch (...) {
28017       {
28018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28019       };
28020     }
28021   }
28022   jresult = (void *)result;
28023   return jresult;
28024 }
28025
28026
28027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28028   void * jresult ;
28029   Dali::LongPressGesture *arg1 = 0 ;
28030   Dali::LongPressGesture *result = 0 ;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   if (!arg1) {
28034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28035     return 0;
28036   }
28037   {
28038     try {
28039       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28040     } catch (std::out_of_range& e) {
28041       {
28042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28043       };
28044     } catch (std::exception& e) {
28045       {
28046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28047       };
28048     } catch (...) {
28049       {
28050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28051       };
28052     }
28053   }
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28060   void * jresult ;
28061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28062   Dali::LongPressGesture *arg2 = 0 ;
28063   Dali::LongPressGesture *result = 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (Dali::LongPressGesture *)jarg2;
28067   if (!arg2) {
28068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28069     return 0;
28070   }
28071   {
28072     try {
28073       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28074     } catch (std::out_of_range& e) {
28075       {
28076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28077       };
28078     } catch (std::exception& e) {
28079       {
28080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28081       };
28082     } catch (...) {
28083       {
28084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28085       };
28086     }
28087   }
28088   jresult = (void *)result;
28089   return jresult;
28090 }
28091
28092
28093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28094   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28095
28096   arg1 = (Dali::LongPressGesture *)jarg1;
28097   {
28098     try {
28099       delete arg1;
28100     } catch (std::out_of_range& e) {
28101       {
28102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28103       };
28104     } catch (std::exception& e) {
28105       {
28106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28107       };
28108     } catch (...) {
28109       {
28110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28111       };
28112     }
28113   }
28114 }
28115
28116
28117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28118   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28119   unsigned int arg2 ;
28120
28121   arg1 = (Dali::LongPressGesture *)jarg1;
28122   arg2 = (unsigned int)jarg2;
28123   if (arg1) (arg1)->numberOfTouches = arg2;
28124 }
28125
28126
28127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28128   unsigned int jresult ;
28129   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28130   unsigned int result;
28131
28132   arg1 = (Dali::LongPressGesture *)jarg1;
28133   result = (unsigned int) ((arg1)->numberOfTouches);
28134   jresult = result;
28135   return jresult;
28136 }
28137
28138
28139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28140   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28141   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28142
28143   arg1 = (Dali::LongPressGesture *)jarg1;
28144   arg2 = (Dali::Vector2 *)jarg2;
28145   if (arg1) (arg1)->screenPoint = *arg2;
28146 }
28147
28148
28149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28150   void * jresult ;
28151   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28152   Dali::Vector2 *result = 0 ;
28153
28154   arg1 = (Dali::LongPressGesture *)jarg1;
28155   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28156   jresult = (void *)result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28162   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28164
28165   arg1 = (Dali::LongPressGesture *)jarg1;
28166   arg2 = (Dali::Vector2 *)jarg2;
28167   if (arg1) (arg1)->localPoint = *arg2;
28168 }
28169
28170
28171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28172   void * jresult ;
28173   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28174   Dali::Vector2 *result = 0 ;
28175
28176   arg1 = (Dali::LongPressGesture *)jarg1;
28177   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28178   jresult = (void *)result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28184   void * jresult ;
28185   Dali::WheelEvent *result = 0 ;
28186
28187   {
28188     try {
28189       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28190     } catch (std::out_of_range& e) {
28191       {
28192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28193       };
28194     } catch (std::exception& e) {
28195       {
28196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28197       };
28198     } catch (...) {
28199       {
28200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28201       };
28202     }
28203   }
28204   jresult = (void *)result;
28205   return jresult;
28206 }
28207
28208
28209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28210   void * jresult ;
28211   Dali::WheelEvent::Type arg1 ;
28212   int arg2 ;
28213   unsigned int arg3 ;
28214   Dali::Vector2 arg4 ;
28215   int arg5 ;
28216   unsigned int arg6 ;
28217   Dali::Vector2 *argp4 ;
28218   Dali::WheelEvent *result = 0 ;
28219
28220   arg1 = (Dali::WheelEvent::Type)jarg1;
28221   arg2 = (int)jarg2;
28222   arg3 = (unsigned int)jarg3;
28223   argp4 = (Dali::Vector2 *)jarg4;
28224   if (!argp4) {
28225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28226     return 0;
28227   }
28228   arg4 = *argp4;
28229   arg5 = (int)jarg5;
28230   arg6 = (unsigned int)jarg6;
28231   {
28232     try {
28233       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28234     } catch (std::out_of_range& e) {
28235       {
28236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (std::exception& e) {
28239       {
28240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28241       };
28242     } catch (...) {
28243       {
28244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28245       };
28246     }
28247   }
28248   jresult = (void *)result;
28249   return jresult;
28250 }
28251
28252
28253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28254   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28255
28256   arg1 = (Dali::WheelEvent *)jarg1;
28257   {
28258     try {
28259       delete arg1;
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28267       };
28268     } catch (...) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28271       };
28272     }
28273   }
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28278   unsigned int jresult ;
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   bool result;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   {
28284     try {
28285       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28286     } catch (std::out_of_range& e) {
28287       {
28288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28289       };
28290     } catch (std::exception& e) {
28291       {
28292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28293       };
28294     } catch (...) {
28295       {
28296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28297       };
28298     }
28299   }
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28306   unsigned int jresult ;
28307   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28308   bool result;
28309
28310   arg1 = (Dali::WheelEvent *)jarg1;
28311   {
28312     try {
28313       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28314     } catch (std::out_of_range& e) {
28315       {
28316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (std::exception& e) {
28319       {
28320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28325       };
28326     }
28327   }
28328   jresult = result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28334   unsigned int jresult ;
28335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28336   bool result;
28337
28338   arg1 = (Dali::WheelEvent *)jarg1;
28339   {
28340     try {
28341       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28342     } catch (std::out_of_range& e) {
28343       {
28344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28345       };
28346     } catch (std::exception& e) {
28347       {
28348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28349       };
28350     } catch (...) {
28351       {
28352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28353       };
28354     }
28355   }
28356   jresult = result;
28357   return jresult;
28358 }
28359
28360
28361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28362   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28363   Dali::WheelEvent::Type arg2 ;
28364
28365   arg1 = (Dali::WheelEvent *)jarg1;
28366   arg2 = (Dali::WheelEvent::Type)jarg2;
28367   if (arg1) (arg1)->type = arg2;
28368 }
28369
28370
28371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28372   int jresult ;
28373   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28374   Dali::WheelEvent::Type result;
28375
28376   arg1 = (Dali::WheelEvent *)jarg1;
28377   result = (Dali::WheelEvent::Type) ((arg1)->type);
28378   jresult = (int)result;
28379   return jresult;
28380 }
28381
28382
28383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28384   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28385   int arg2 ;
28386
28387   arg1 = (Dali::WheelEvent *)jarg1;
28388   arg2 = (int)jarg2;
28389   if (arg1) (arg1)->direction = arg2;
28390 }
28391
28392
28393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28394   int jresult ;
28395   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28396   int result;
28397
28398   arg1 = (Dali::WheelEvent *)jarg1;
28399   result = (int) ((arg1)->direction);
28400   jresult = result;
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28406   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28407   unsigned int arg2 ;
28408
28409   arg1 = (Dali::WheelEvent *)jarg1;
28410   arg2 = (unsigned int)jarg2;
28411   if (arg1) (arg1)->modifiers = arg2;
28412 }
28413
28414
28415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28416   unsigned int jresult ;
28417   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28418   unsigned int result;
28419
28420   arg1 = (Dali::WheelEvent *)jarg1;
28421   result = (unsigned int) ((arg1)->modifiers);
28422   jresult = result;
28423   return jresult;
28424 }
28425
28426
28427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28428   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28429   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28430
28431   arg1 = (Dali::WheelEvent *)jarg1;
28432   arg2 = (Dali::Vector2 *)jarg2;
28433   if (arg1) (arg1)->point = *arg2;
28434 }
28435
28436
28437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28438   void * jresult ;
28439   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28440   Dali::Vector2 *result = 0 ;
28441
28442   arg1 = (Dali::WheelEvent *)jarg1;
28443   result = (Dali::Vector2 *)& ((arg1)->point);
28444   jresult = (void *)result;
28445   return jresult;
28446 }
28447
28448
28449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28450   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28451   int arg2 ;
28452
28453   arg1 = (Dali::WheelEvent *)jarg1;
28454   arg2 = (int)jarg2;
28455   if (arg1) (arg1)->z = arg2;
28456 }
28457
28458
28459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28460   int jresult ;
28461   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28462   int result;
28463
28464   arg1 = (Dali::WheelEvent *)jarg1;
28465   result = (int) ((arg1)->z);
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28472   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28473   unsigned int arg2 ;
28474
28475   arg1 = (Dali::WheelEvent *)jarg1;
28476   arg2 = (unsigned int)jarg2;
28477   if (arg1) (arg1)->timeStamp = arg2;
28478 }
28479
28480
28481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28482   unsigned int jresult ;
28483   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28484   unsigned int result;
28485
28486   arg1 = (Dali::WheelEvent *)jarg1;
28487   result = (unsigned int) ((arg1)->timeStamp);
28488   jresult = result;
28489   return jresult;
28490 }
28491
28492 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28493   char * jresult ;
28494   Dali::KeyEvent *arg1 = 0 ;
28495   std::string result;
28496
28497   arg1 = (Dali::KeyEvent *)jarg1;
28498   if (!arg1) {
28499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28500     return 0;
28501   }
28502   {
28503     try {
28504       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28505     } catch (std::out_of_range& e) {
28506       {
28507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28508       };
28509     } catch (std::exception& e) {
28510       {
28511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (...) {
28514       {
28515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28516       };
28517     }
28518   }
28519   jresult = SWIG_csharp_string_callback((&result)->c_str());
28520   return jresult;
28521 }
28522
28523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28524   int jresult ;
28525   Dali::KeyEvent *arg1 = 0 ;
28526   Dali::DevelKeyEvent::DeviceClass::Type result;
28527
28528   arg1 = (Dali::KeyEvent *)jarg1;
28529   if (!arg1) {
28530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28531     return 0;
28532   }
28533   {
28534     try {
28535       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28536     } catch (std::out_of_range& e) {
28537       {
28538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28539       };
28540     } catch (std::exception& e) {
28541       {
28542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28543       };
28544     } catch (...) {
28545       {
28546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28547       };
28548     }
28549   }
28550   jresult = (int)result;
28551   return jresult;
28552 }
28553
28554
28555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28556   Dali::Actor arg1 ;
28557   Dali::Actor *argp1 ;
28558
28559   argp1 = (Dali::Actor *)jarg1;
28560   if (!argp1) {
28561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28562     return ;
28563   }
28564   arg1 = *argp1;
28565   {
28566     try {
28567       Dali::DevelActor::Raise(arg1);
28568     } catch (std::out_of_range& e) {
28569       {
28570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28571       };
28572     } catch (std::exception& e) {
28573       {
28574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28579       };
28580     }
28581   }
28582 }
28583
28584
28585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28586   Dali::Actor arg1 ;
28587   Dali::Actor *argp1 ;
28588
28589   argp1 = (Dali::Actor *)jarg1;
28590   if (!argp1) {
28591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28592     return ;
28593   }
28594   arg1 = *argp1;
28595   {
28596     try {
28597       Dali::DevelActor::Lower(arg1);
28598     } catch (std::out_of_range& e) {
28599       {
28600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28601       };
28602     } catch (std::exception& e) {
28603       {
28604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28605       };
28606     } catch (...) {
28607       {
28608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28609       };
28610     }
28611   }
28612 }
28613
28614
28615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28616   Dali::Actor arg1 ;
28617   Dali::Actor *argp1 ;
28618
28619   argp1 = (Dali::Actor *)jarg1;
28620   if (!argp1) {
28621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28622     return ;
28623   }
28624   arg1 = *argp1;
28625   {
28626     try {
28627       Dali::DevelActor::RaiseToTop(arg1);
28628     } catch (std::out_of_range& e) {
28629       {
28630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28631       };
28632     } catch (std::exception& e) {
28633       {
28634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28635       };
28636     } catch (...) {
28637       {
28638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28639       };
28640     }
28641   }
28642 }
28643
28644
28645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28646   Dali::Actor arg1 ;
28647   Dali::Actor *argp1 ;
28648
28649   argp1 = (Dali::Actor *)jarg1;
28650   if (!argp1) {
28651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28652     return ;
28653   }
28654   arg1 = *argp1;
28655   {
28656     try {
28657       Dali::DevelActor::LowerToBottom(arg1);
28658     } catch (std::out_of_range& e) {
28659       {
28660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28661       };
28662     } catch (std::exception& e) {
28663       {
28664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28669       };
28670     }
28671   }
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28676   Dali::Actor arg1 ;
28677   Dali::Actor arg2 ;
28678   Dali::Actor *argp1 ;
28679   Dali::Actor *argp2 ;
28680
28681   argp1 = (Dali::Actor *)jarg1;
28682   if (!argp1) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28684     return ;
28685   }
28686   arg1 = *argp1;
28687   argp2 = (Dali::Actor *)jarg2;
28688   if (!argp2) {
28689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28690     return ;
28691   }
28692   arg2 = *argp2;
28693   {
28694     try {
28695       Dali::DevelActor::RaiseAbove(arg1,arg2);
28696     } catch (std::out_of_range& e) {
28697       {
28698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28699       };
28700     } catch (std::exception& e) {
28701       {
28702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28703       };
28704     } catch (...) {
28705       {
28706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28707       };
28708     }
28709   }
28710 }
28711
28712
28713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28714   Dali::Actor arg1 ;
28715   Dali::Actor arg2 ;
28716   Dali::Actor *argp1 ;
28717   Dali::Actor *argp2 ;
28718
28719   argp1 = (Dali::Actor *)jarg1;
28720   if (!argp1) {
28721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28722     return ;
28723   }
28724   arg1 = *argp1;
28725   argp2 = (Dali::Actor *)jarg2;
28726   if (!argp2) {
28727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28728     return ;
28729   }
28730   arg2 = *argp2;
28731   {
28732     try {
28733       Dali::DevelActor::LowerBelow(arg1,arg2);
28734     } catch (std::out_of_range& e) {
28735       {
28736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28737       };
28738     } catch (std::exception& e) {
28739       {
28740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28741       };
28742     } catch (...) {
28743       {
28744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28745       };
28746     }
28747   }
28748 }
28749
28750
28751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28752   void * jresult ;
28753   Dali::Actor arg1 ;
28754   Dali::Actor *argp1 ;
28755   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28756
28757   argp1 = (Dali::Actor *)jarg1;
28758   if (!argp1) {
28759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28760     return 0;
28761   }
28762   arg1 = *argp1;
28763   {
28764     try {
28765       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28766     } catch (std::out_of_range& e) {
28767       {
28768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28769       };
28770     } catch (std::exception& e) {
28771       {
28772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28773       };
28774     } catch (...) {
28775       {
28776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28777       };
28778     }
28779   }
28780   jresult = (void *)result;
28781   return jresult;
28782 }
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::SIZE;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::POSITION;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::POSITION_X;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::POSITION_Y;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::POSITION_Z;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::WORLD_POSITION;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::ORIENTATION;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::SCALE;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::SCALE_X;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::SCALE_Y;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::SCALE_Z;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::WORLD_SCALE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::VISIBLE;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::COLOR;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29075   int jresult ;
29076   int result;
29077
29078   result = (int)Dali::Actor::Property::COLOR_RED;
29079   jresult = (int)result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29085   int jresult ;
29086   int result;
29087
29088   result = (int)Dali::Actor::Property::COLOR_GREEN;
29089   jresult = (int)result;
29090   return jresult;
29091 }
29092
29093
29094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29095   int jresult ;
29096   int result;
29097
29098   result = (int)Dali::Actor::Property::COLOR_BLUE;
29099   jresult = (int)result;
29100   return jresult;
29101 }
29102
29103
29104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29105   int jresult ;
29106   int result;
29107
29108   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29109   jresult = (int)result;
29110   return jresult;
29111 }
29112
29113
29114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29115   int jresult ;
29116   int result;
29117
29118   result = (int)Dali::Actor::Property::WORLD_COLOR;
29119   jresult = (int)result;
29120   return jresult;
29121 }
29122
29123
29124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29125   int jresult ;
29126   int result;
29127
29128   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29129   jresult = (int)result;
29130   return jresult;
29131 }
29132
29133
29134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29135   int jresult ;
29136   int result;
29137
29138   result = (int)Dali::Actor::Property::NAME;
29139   jresult = (int)result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29145   int jresult ;
29146   int result;
29147
29148   result = (int)Dali::Actor::Property::SENSITIVE;
29149   jresult = (int)result;
29150   return jresult;
29151 }
29152
29153
29154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29155   int jresult ;
29156   int result;
29157
29158   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29159   jresult = (int)result;
29160   return jresult;
29161 }
29162
29163
29164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29165   int jresult ;
29166   int result;
29167
29168   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29175   int jresult ;
29176   int result;
29177
29178   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29179   jresult = (int)result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29185   int jresult ;
29186   int result;
29187
29188   result = (int)Dali::Actor::Property::COLOR_MODE;
29189   jresult = (int)result;
29190   return jresult;
29191 }
29192
29193
29194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29195   int jresult ;
29196   int result;
29197
29198   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29199   jresult = (int)result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29205   int jresult ;
29206   int result;
29207
29208   result = (int)Dali::Actor::Property::DRAW_MODE;
29209   jresult = (int)result;
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29215   int jresult ;
29216   int result;
29217
29218   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29219   jresult = (int)result;
29220   return jresult;
29221 }
29222
29223
29224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29225   int jresult ;
29226   int result;
29227
29228   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29229   jresult = (int)result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29235   int jresult ;
29236   int result;
29237
29238   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29239   jresult = (int)result;
29240   return jresult;
29241 }
29242
29243
29244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29245   int jresult ;
29246   int result;
29247
29248   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29249   jresult = (int)result;
29250   return jresult;
29251 }
29252
29253
29254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29255   int jresult ;
29256   int result;
29257
29258   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29259   jresult = (int)result;
29260   return jresult;
29261 }
29262
29263
29264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29265   int jresult ;
29266   int result;
29267
29268   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29269   jresult = (int)result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29275   int jresult ;
29276   int result;
29277
29278   result = (int)Dali::Actor::Property::PADDING;
29279   jresult = (int)result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29285   int jresult ;
29286   int result;
29287
29288   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29289   jresult = (int)result;
29290   return jresult;
29291 }
29292
29293
29294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29295   int jresult ;
29296   int result;
29297
29298   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29299   jresult = (int)result;
29300   return jresult;
29301 }
29302
29303
29304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29305   int jresult ;
29306   int result;
29307
29308   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29309   jresult = (int)result;
29310   return jresult;
29311 }
29312
29313
29314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29315   int jresult ;
29316   int result;
29317
29318   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29319   jresult = (int)result;
29320   return jresult;
29321 }
29322
29323
29324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29325   void * jresult ;
29326   Dali::Actor::Property *result = 0 ;
29327
29328   {
29329     try {
29330       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29331     } catch (std::out_of_range& e) {
29332       {
29333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29334       };
29335     } catch (std::exception& e) {
29336       {
29337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29338       };
29339     } catch (...) {
29340       {
29341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29342       };
29343     }
29344   }
29345   jresult = (void *)result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29351   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29352
29353   arg1 = (Dali::Actor::Property *)jarg1;
29354   {
29355     try {
29356       delete arg1;
29357     } catch (std::out_of_range& e) {
29358       {
29359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (std::exception& e) {
29362       {
29363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371 }
29372
29373
29374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29375   void * jresult ;
29376   Dali::Actor *result = 0 ;
29377
29378   {
29379     try {
29380       result = (Dali::Actor *)new Dali::Actor();
29381     } catch (std::out_of_range& e) {
29382       {
29383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (std::exception& e) {
29386       {
29387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29401   void * jresult ;
29402   Dali::Actor result;
29403
29404   {
29405     try {
29406       result = Dali::Actor::New();
29407     } catch (std::out_of_range& e) {
29408       {
29409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29410       };
29411     } catch (std::exception& e) {
29412       {
29413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29414       };
29415     } catch (...) {
29416       {
29417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29418       };
29419     }
29420   }
29421   jresult = new Dali::Actor((const Dali::Actor &)result);
29422   return jresult;
29423 }
29424
29425
29426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29427   void * jresult ;
29428   Dali::BaseHandle arg1 ;
29429   Dali::BaseHandle *argp1 ;
29430   Dali::Actor result;
29431
29432   argp1 = (Dali::BaseHandle *)jarg1;
29433   if (!argp1) {
29434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29435     return 0;
29436   }
29437   arg1 = *argp1;
29438   {
29439     try {
29440       result = Dali::Actor::DownCast(arg1);
29441     } catch (std::out_of_range& e) {
29442       {
29443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29444       };
29445     } catch (std::exception& e) {
29446       {
29447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (...) {
29450       {
29451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29452       };
29453     }
29454   }
29455   jresult = new Dali::Actor((const Dali::Actor &)result);
29456   return jresult;
29457 }
29458
29459
29460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29462
29463   arg1 = (Dali::Actor *)jarg1;
29464   {
29465     try {
29466       delete arg1;
29467     } catch (std::out_of_range& e) {
29468       {
29469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29470       };
29471     } catch (std::exception& e) {
29472       {
29473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29474       };
29475     } catch (...) {
29476       {
29477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29478       };
29479     }
29480   }
29481 }
29482
29483
29484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29485   void * jresult ;
29486   Dali::Actor *arg1 = 0 ;
29487   Dali::Actor *result = 0 ;
29488
29489   arg1 = (Dali::Actor *)jarg1;
29490   if (!arg1) {
29491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29492     return 0;
29493   }
29494   {
29495     try {
29496       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29508       };
29509     }
29510   }
29511   jresult = (void *)result;
29512   return jresult;
29513 }
29514
29515
29516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29517   void * jresult ;
29518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29519   Dali::Actor *arg2 = 0 ;
29520   Dali::Actor *result = 0 ;
29521
29522   arg1 = (Dali::Actor *)jarg1;
29523   arg2 = (Dali::Actor *)jarg2;
29524   if (!arg2) {
29525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29526     return 0;
29527   }
29528   {
29529     try {
29530       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (...) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29542       };
29543     }
29544   }
29545   jresult = (void *)result;
29546   return jresult;
29547 }
29548
29549
29550 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29551   char * jresult ;
29552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29553   std::string *result = 0 ;
29554
29555   arg1 = (Dali::Actor *)jarg1;
29556   {
29557     try {
29558       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29566       };
29567     } catch (...) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29570       };
29571     }
29572   }
29573   jresult = SWIG_csharp_string_callback(result->c_str());
29574   return jresult;
29575 }
29576
29577
29578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29580   std::string *arg2 = 0 ;
29581
29582   arg1 = (Dali::Actor *)jarg1;
29583   if (!jarg2) {
29584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29585     return ;
29586   }
29587   std::string arg2_str(jarg2);
29588   arg2 = &arg2_str;
29589   {
29590     try {
29591       (arg1)->SetName((std::string const &)*arg2);
29592     } catch (std::out_of_range& e) {
29593       {
29594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29595       };
29596     } catch (std::exception& e) {
29597       {
29598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29599       };
29600     } catch (...) {
29601       {
29602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29603       };
29604     }
29605   }
29606
29607   //argout typemap for const std::string&
29608
29609 }
29610
29611
29612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29613   unsigned int jresult ;
29614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29615   unsigned int result;
29616
29617   arg1 = (Dali::Actor *)jarg1;
29618   {
29619     try {
29620       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29621     } catch (std::out_of_range& e) {
29622       {
29623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29624       };
29625     } catch (std::exception& e) {
29626       {
29627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29628       };
29629     } catch (...) {
29630       {
29631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29632       };
29633     }
29634   }
29635   jresult = result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29641   unsigned int jresult ;
29642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29643   bool result;
29644
29645   arg1 = (Dali::Actor *)jarg1;
29646   {
29647     try {
29648       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29649     } catch (std::out_of_range& e) {
29650       {
29651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29652       };
29653     } catch (std::exception& e) {
29654       {
29655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (...) {
29658       {
29659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29660       };
29661     }
29662   }
29663   jresult = result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29669   unsigned int jresult ;
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   bool result;
29672
29673   arg1 = (Dali::Actor *)jarg1;
29674   {
29675     try {
29676       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29677     } catch (std::out_of_range& e) {
29678       {
29679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29680       };
29681     } catch (std::exception& e) {
29682       {
29683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29684       };
29685     } catch (...) {
29686       {
29687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29688       };
29689     }
29690   }
29691   jresult = result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29697   unsigned int jresult ;
29698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29699   bool result;
29700
29701   arg1 = (Dali::Actor *)jarg1;
29702   {
29703     try {
29704       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29705     } catch (std::out_of_range& e) {
29706       {
29707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (std::exception& e) {
29710       {
29711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719   jresult = result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29725   void * jresult ;
29726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29727   Dali::Layer result;
29728
29729   arg1 = (Dali::Actor *)jarg1;
29730   {
29731     try {
29732       result = (arg1)->GetLayer();
29733     } catch (std::out_of_range& e) {
29734       {
29735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29736       };
29737     } catch (std::exception& e) {
29738       {
29739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29740       };
29741     } catch (...) {
29742       {
29743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29744       };
29745     }
29746   }
29747   jresult = new Dali::Layer((const Dali::Layer &)result);
29748   return jresult;
29749 }
29750
29751
29752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29754   Dali::Actor arg2 ;
29755   Dali::Actor *argp2 ;
29756
29757   arg1 = (Dali::Actor *)jarg1;
29758   argp2 = (Dali::Actor *)jarg2;
29759   if (!argp2) {
29760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29761     return ;
29762   }
29763   arg2 = *argp2;
29764   {
29765     try {
29766       (arg1)->Add(arg2);
29767     } catch (std::out_of_range& e) {
29768       {
29769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29770       };
29771     } catch (std::exception& e) {
29772       {
29773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29774       };
29775     } catch (...) {
29776       {
29777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29778       };
29779     }
29780   }
29781 }
29782
29783
29784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29786   Dali::Actor arg2 ;
29787   Dali::Actor *argp2 ;
29788
29789   arg1 = (Dali::Actor *)jarg1;
29790   argp2 = (Dali::Actor *)jarg2;
29791   if (!argp2) {
29792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29793     return ;
29794   }
29795   arg2 = *argp2;
29796   {
29797     try {
29798       (arg1)->Remove(arg2);
29799     } catch (std::out_of_range& e) {
29800       {
29801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29802       };
29803     } catch (std::exception& e) {
29804       {
29805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29806       };
29807     } catch (...) {
29808       {
29809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29810       };
29811     }
29812   }
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29818
29819   arg1 = (Dali::Actor *)jarg1;
29820   {
29821     try {
29822       (arg1)->Unparent();
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (...) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29834       };
29835     }
29836   }
29837 }
29838
29839
29840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29841   unsigned int jresult ;
29842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29843   unsigned int result;
29844
29845   arg1 = (Dali::Actor *)jarg1;
29846   {
29847     try {
29848       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29849     } catch (std::out_of_range& e) {
29850       {
29851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (std::exception& e) {
29854       {
29855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29856       };
29857     } catch (...) {
29858       {
29859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29860       };
29861     }
29862   }
29863   jresult = result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29869   void * jresult ;
29870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29871   unsigned int arg2 ;
29872   Dali::Actor result;
29873
29874   arg1 = (Dali::Actor *)jarg1;
29875   arg2 = (unsigned int)jarg2;
29876   {
29877     try {
29878       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29879     } catch (std::out_of_range& e) {
29880       {
29881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (std::exception& e) {
29884       {
29885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29886       };
29887     } catch (...) {
29888       {
29889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29890       };
29891     }
29892   }
29893   jresult = new Dali::Actor((const Dali::Actor &)result);
29894   return jresult;
29895 }
29896
29897
29898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29899   void * jresult ;
29900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29901   std::string *arg2 = 0 ;
29902   Dali::Actor result;
29903
29904   arg1 = (Dali::Actor *)jarg1;
29905   if (!jarg2) {
29906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29907     return 0;
29908   }
29909   std::string arg2_str(jarg2);
29910   arg2 = &arg2_str;
29911   {
29912     try {
29913       result = (arg1)->FindChildByName((std::string const &)*arg2);
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (...) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29925       };
29926     }
29927   }
29928   jresult = new Dali::Actor((const Dali::Actor &)result);
29929
29930   //argout typemap for const std::string&
29931
29932   return jresult;
29933 }
29934
29935
29936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29937   void * jresult ;
29938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29939   unsigned int arg2 ;
29940   Dali::Actor result;
29941
29942   arg1 = (Dali::Actor *)jarg1;
29943   arg2 = (unsigned int)jarg2;
29944   {
29945     try {
29946       result = (arg1)->FindChildById(arg2);
29947     } catch (std::out_of_range& e) {
29948       {
29949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (std::exception& e) {
29952       {
29953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961   jresult = new Dali::Actor((const Dali::Actor &)result);
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29967   void * jresult ;
29968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29969   Dali::Actor result;
29970
29971   arg1 = (Dali::Actor *)jarg1;
29972   {
29973     try {
29974       result = ((Dali::Actor const *)arg1)->GetParent();
29975     } catch (std::out_of_range& e) {
29976       {
29977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29978       };
29979     } catch (std::exception& e) {
29980       {
29981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (...) {
29984       {
29985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29986       };
29987     }
29988   }
29989   jresult = new Dali::Actor((const Dali::Actor &)result);
29990   return jresult;
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29996   Dali::Vector3 *arg2 = 0 ;
29997
29998   arg1 = (Dali::Actor *)jarg1;
29999   arg2 = (Dali::Vector3 *)jarg2;
30000   if (!arg2) {
30001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30002     return ;
30003   }
30004   {
30005     try {
30006       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30014       };
30015     } catch (...) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30018       };
30019     }
30020   }
30021 }
30022
30023
30024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30025   void * jresult ;
30026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30027   Dali::Vector3 result;
30028
30029   arg1 = (Dali::Actor *)jarg1;
30030   {
30031     try {
30032       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (...) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30044       };
30045     }
30046   }
30047   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30048   return jresult;
30049 }
30050
30051
30052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30054   Dali::Vector3 *arg2 = 0 ;
30055
30056   arg1 = (Dali::Actor *)jarg1;
30057   arg2 = (Dali::Vector3 *)jarg2;
30058   if (!arg2) {
30059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30060     return ;
30061   }
30062   {
30063     try {
30064       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30065     } catch (std::out_of_range& e) {
30066       {
30067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30068       };
30069     } catch (std::exception& e) {
30070       {
30071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30072       };
30073     } catch (...) {
30074       {
30075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30076       };
30077     }
30078   }
30079 }
30080
30081
30082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30083   void * jresult ;
30084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30085   Dali::Vector3 result;
30086
30087   arg1 = (Dali::Actor *)jarg1;
30088   {
30089     try {
30090       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30091     } catch (std::out_of_range& e) {
30092       {
30093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30094       };
30095     } catch (std::exception& e) {
30096       {
30097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30102       };
30103     }
30104   }
30105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30112   float arg2 ;
30113   float arg3 ;
30114
30115   arg1 = (Dali::Actor *)jarg1;
30116   arg2 = (float)jarg2;
30117   arg3 = (float)jarg3;
30118   {
30119     try {
30120       (arg1)->SetSize(arg2,arg3);
30121     } catch (std::out_of_range& e) {
30122       {
30123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30124       };
30125     } catch (std::exception& e) {
30126       {
30127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30132       };
30133     }
30134   }
30135 }
30136
30137
30138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30140   float arg2 ;
30141   float arg3 ;
30142   float arg4 ;
30143
30144   arg1 = (Dali::Actor *)jarg1;
30145   arg2 = (float)jarg2;
30146   arg3 = (float)jarg3;
30147   arg4 = (float)jarg4;
30148   {
30149     try {
30150       (arg1)->SetSize(arg2,arg3,arg4);
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30158       };
30159     } catch (...) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30162       };
30163     }
30164   }
30165 }
30166
30167
30168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30170   Dali::Vector2 *arg2 = 0 ;
30171
30172   arg1 = (Dali::Actor *)jarg1;
30173   arg2 = (Dali::Vector2 *)jarg2;
30174   if (!arg2) {
30175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30176     return ;
30177   }
30178   {
30179     try {
30180       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30181     } catch (std::out_of_range& e) {
30182       {
30183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30184       };
30185     } catch (std::exception& e) {
30186       {
30187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30192       };
30193     }
30194   }
30195 }
30196
30197
30198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30200   Dali::Vector3 *arg2 = 0 ;
30201
30202   arg1 = (Dali::Actor *)jarg1;
30203   arg2 = (Dali::Vector3 *)jarg2;
30204   if (!arg2) {
30205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30206     return ;
30207   }
30208   {
30209     try {
30210       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30211     } catch (std::out_of_range& e) {
30212       {
30213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30214       };
30215     } catch (std::exception& e) {
30216       {
30217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30218       };
30219     } catch (...) {
30220       {
30221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30222       };
30223     }
30224   }
30225 }
30226
30227
30228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30229   void * jresult ;
30230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30231   Dali::Vector3 result;
30232
30233   arg1 = (Dali::Actor *)jarg1;
30234   {
30235     try {
30236       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30237     } catch (std::out_of_range& e) {
30238       {
30239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30240       };
30241     } catch (std::exception& e) {
30242       {
30243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (...) {
30246       {
30247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30248       };
30249     }
30250   }
30251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30252   return jresult;
30253 }
30254
30255
30256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30257   void * jresult ;
30258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30259   Dali::Vector3 result;
30260
30261   arg1 = (Dali::Actor *)jarg1;
30262   {
30263     try {
30264       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30265     } catch (std::out_of_range& e) {
30266       {
30267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30268       };
30269     } catch (std::exception& e) {
30270       {
30271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30276       };
30277     }
30278   }
30279   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30280   return jresult;
30281 }
30282
30283
30284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30285   void * jresult ;
30286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30287   Dali::Vector3 result;
30288
30289   arg1 = (Dali::Actor *)jarg1;
30290   {
30291     try {
30292       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30304       };
30305     }
30306   }
30307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30308   return jresult;
30309 }
30310
30311
30312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30314   float arg2 ;
30315   float arg3 ;
30316
30317   arg1 = (Dali::Actor *)jarg1;
30318   arg2 = (float)jarg2;
30319   arg3 = (float)jarg3;
30320   {
30321     try {
30322       (arg1)->SetPosition(arg2,arg3);
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30334       };
30335     }
30336   }
30337 }
30338
30339
30340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30342   float arg2 ;
30343   float arg3 ;
30344   float arg4 ;
30345
30346   arg1 = (Dali::Actor *)jarg1;
30347   arg2 = (float)jarg2;
30348   arg3 = (float)jarg3;
30349   arg4 = (float)jarg4;
30350   {
30351     try {
30352       (arg1)->SetPosition(arg2,arg3,arg4);
30353     } catch (std::out_of_range& e) {
30354       {
30355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30356       };
30357     } catch (std::exception& e) {
30358       {
30359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30364       };
30365     }
30366   }
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30372   Dali::Vector3 *arg2 = 0 ;
30373
30374   arg1 = (Dali::Actor *)jarg1;
30375   arg2 = (Dali::Vector3 *)jarg2;
30376   if (!arg2) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30378     return ;
30379   }
30380   {
30381     try {
30382       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30383     } catch (std::out_of_range& e) {
30384       {
30385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30386       };
30387     } catch (std::exception& e) {
30388       {
30389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30390       };
30391     } catch (...) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30394       };
30395     }
30396   }
30397 }
30398
30399
30400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30402   float arg2 ;
30403
30404   arg1 = (Dali::Actor *)jarg1;
30405   arg2 = (float)jarg2;
30406   {
30407     try {
30408       (arg1)->SetX(arg2);
30409     } catch (std::out_of_range& e) {
30410       {
30411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30412       };
30413     } catch (std::exception& e) {
30414       {
30415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30420       };
30421     }
30422   }
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   float arg2 ;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   arg2 = (float)jarg2;
30432   {
30433     try {
30434       (arg1)->SetY(arg2);
30435     } catch (std::out_of_range& e) {
30436       {
30437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (std::exception& e) {
30440       {
30441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (...) {
30444       {
30445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30446       };
30447     }
30448   }
30449 }
30450
30451
30452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30454   float arg2 ;
30455
30456   arg1 = (Dali::Actor *)jarg1;
30457   arg2 = (float)jarg2;
30458   {
30459     try {
30460       (arg1)->SetZ(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (...) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30472       };
30473     }
30474   }
30475 }
30476
30477
30478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30480   Dali::Vector3 *arg2 = 0 ;
30481
30482   arg1 = (Dali::Actor *)jarg1;
30483   arg2 = (Dali::Vector3 *)jarg2;
30484   if (!arg2) {
30485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30486     return ;
30487   }
30488   {
30489     try {
30490       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30491     } catch (std::out_of_range& e) {
30492       {
30493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30494       };
30495     } catch (std::exception& e) {
30496       {
30497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30498       };
30499     } catch (...) {
30500       {
30501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30502       };
30503     }
30504   }
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30509   void * jresult ;
30510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30511   Dali::Vector3 result;
30512
30513   arg1 = (Dali::Actor *)jarg1;
30514   {
30515     try {
30516       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30517     } catch (std::out_of_range& e) {
30518       {
30519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30520       };
30521     } catch (std::exception& e) {
30522       {
30523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30524       };
30525     } catch (...) {
30526       {
30527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30528       };
30529     }
30530   }
30531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30537   void * jresult ;
30538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30539   Dali::Vector3 result;
30540
30541   arg1 = (Dali::Actor *)jarg1;
30542   {
30543     try {
30544       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30545     } catch (std::out_of_range& e) {
30546       {
30547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30548       };
30549     } catch (std::exception& e) {
30550       {
30551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30552       };
30553     } catch (...) {
30554       {
30555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30556       };
30557     }
30558   }
30559   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30560   return jresult;
30561 }
30562
30563
30564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30566   bool arg2 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = jarg2 ? true : false;
30570   {
30571     try {
30572       (arg1)->SetInheritPosition(arg2);
30573     } catch (std::out_of_range& e) {
30574       {
30575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30576       };
30577     } catch (std::exception& e) {
30578       {
30579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30584       };
30585     }
30586   }
30587 }
30588
30589
30590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30591   int jresult ;
30592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30593   Dali::PositionInheritanceMode result;
30594
30595   arg1 = (Dali::Actor *)jarg1;
30596   {
30597     try {
30598       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30610       };
30611     }
30612   }
30613   jresult = (int)result;
30614   return jresult;
30615 }
30616
30617
30618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30619   unsigned int jresult ;
30620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30621   bool result;
30622
30623   arg1 = (Dali::Actor *)jarg1;
30624   {
30625     try {
30626       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30627     } catch (std::out_of_range& e) {
30628       {
30629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30630       };
30631     } catch (std::exception& e) {
30632       {
30633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30634       };
30635     } catch (...) {
30636       {
30637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30638       };
30639     }
30640   }
30641   jresult = result;
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30648   Dali::Degree *arg2 = 0 ;
30649   Dali::Vector3 *arg3 = 0 ;
30650
30651   arg1 = (Dali::Actor *)jarg1;
30652   arg2 = (Dali::Degree *)jarg2;
30653   if (!arg2) {
30654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30655     return ;
30656   }
30657   arg3 = (Dali::Vector3 *)jarg3;
30658   if (!arg3) {
30659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30660     return ;
30661   }
30662   {
30663     try {
30664       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30665     } catch (std::out_of_range& e) {
30666       {
30667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30668       };
30669     } catch (std::exception& e) {
30670       {
30671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30676       };
30677     }
30678   }
30679 }
30680
30681
30682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30684   Dali::Radian *arg2 = 0 ;
30685   Dali::Vector3 *arg3 = 0 ;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   arg2 = (Dali::Radian *)jarg2;
30689   if (!arg2) {
30690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30691     return ;
30692   }
30693   arg3 = (Dali::Vector3 *)jarg3;
30694   if (!arg3) {
30695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30696     return ;
30697   }
30698   {
30699     try {
30700       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30701     } catch (std::out_of_range& e) {
30702       {
30703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30704       };
30705     } catch (std::exception& e) {
30706       {
30707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30712       };
30713     }
30714   }
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30720   Dali::Quaternion *arg2 = 0 ;
30721
30722   arg1 = (Dali::Actor *)jarg1;
30723   arg2 = (Dali::Quaternion *)jarg2;
30724   if (!arg2) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30726     return ;
30727   }
30728   {
30729     try {
30730       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745 }
30746
30747
30748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30750   Dali::Degree *arg2 = 0 ;
30751   Dali::Vector3 *arg3 = 0 ;
30752
30753   arg1 = (Dali::Actor *)jarg1;
30754   arg2 = (Dali::Degree *)jarg2;
30755   if (!arg2) {
30756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30757     return ;
30758   }
30759   arg3 = (Dali::Vector3 *)jarg3;
30760   if (!arg3) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30762     return ;
30763   }
30764   {
30765     try {
30766       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30774       };
30775     } catch (...) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30778       };
30779     }
30780   }
30781 }
30782
30783
30784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30786   Dali::Radian *arg2 = 0 ;
30787   Dali::Vector3 *arg3 = 0 ;
30788
30789   arg1 = (Dali::Actor *)jarg1;
30790   arg2 = (Dali::Radian *)jarg2;
30791   if (!arg2) {
30792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30793     return ;
30794   }
30795   arg3 = (Dali::Vector3 *)jarg3;
30796   if (!arg3) {
30797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30798     return ;
30799   }
30800   {
30801     try {
30802       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30814       };
30815     }
30816   }
30817 }
30818
30819
30820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30822   Dali::Quaternion *arg2 = 0 ;
30823
30824   arg1 = (Dali::Actor *)jarg1;
30825   arg2 = (Dali::Quaternion *)jarg2;
30826   if (!arg2) {
30827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30828     return ;
30829   }
30830   {
30831     try {
30832       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30840       };
30841     } catch (...) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30844       };
30845     }
30846   }
30847 }
30848
30849
30850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30851   void * jresult ;
30852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30853   Dali::Quaternion result;
30854
30855   arg1 = (Dali::Actor *)jarg1;
30856   {
30857     try {
30858       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30859     } catch (std::out_of_range& e) {
30860       {
30861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (std::exception& e) {
30864       {
30865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30866       };
30867     } catch (...) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30870       };
30871     }
30872   }
30873   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30880   bool arg2 ;
30881
30882   arg1 = (Dali::Actor *)jarg1;
30883   arg2 = jarg2 ? true : false;
30884   {
30885     try {
30886       (arg1)->SetInheritOrientation(arg2);
30887     } catch (std::out_of_range& e) {
30888       {
30889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30890       };
30891     } catch (std::exception& e) {
30892       {
30893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30894       };
30895     } catch (...) {
30896       {
30897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30898       };
30899     }
30900   }
30901 }
30902
30903
30904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30905   unsigned int jresult ;
30906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30907   bool result;
30908
30909   arg1 = (Dali::Actor *)jarg1;
30910   {
30911     try {
30912       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30913     } catch (std::out_of_range& e) {
30914       {
30915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (std::exception& e) {
30918       {
30919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927   jresult = result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30933   void * jresult ;
30934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30935   Dali::Quaternion result;
30936
30937   arg1 = (Dali::Actor *)jarg1;
30938   {
30939     try {
30940       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (...) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30952       };
30953     }
30954   }
30955   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30956   return jresult;
30957 }
30958
30959
30960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30962   float arg2 ;
30963
30964   arg1 = (Dali::Actor *)jarg1;
30965   arg2 = (float)jarg2;
30966   {
30967     try {
30968       (arg1)->SetScale(arg2);
30969     } catch (std::out_of_range& e) {
30970       {
30971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30972       };
30973     } catch (std::exception& e) {
30974       {
30975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30976       };
30977     } catch (...) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30980       };
30981     }
30982   }
30983 }
30984
30985
30986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30988   float arg2 ;
30989   float arg3 ;
30990   float arg4 ;
30991
30992   arg1 = (Dali::Actor *)jarg1;
30993   arg2 = (float)jarg2;
30994   arg3 = (float)jarg3;
30995   arg4 = (float)jarg4;
30996   {
30997     try {
30998       (arg1)->SetScale(arg2,arg3,arg4);
30999     } catch (std::out_of_range& e) {
31000       {
31001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31002       };
31003     } catch (std::exception& e) {
31004       {
31005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31006       };
31007     } catch (...) {
31008       {
31009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31010       };
31011     }
31012   }
31013 }
31014
31015
31016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31018   Dali::Vector3 *arg2 = 0 ;
31019
31020   arg1 = (Dali::Actor *)jarg1;
31021   arg2 = (Dali::Vector3 *)jarg2;
31022   if (!arg2) {
31023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31024     return ;
31025   }
31026   {
31027     try {
31028       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31036       };
31037     } catch (...) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31040       };
31041     }
31042   }
31043 }
31044
31045
31046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31048   Dali::Vector3 *arg2 = 0 ;
31049
31050   arg1 = (Dali::Actor *)jarg1;
31051   arg2 = (Dali::Vector3 *)jarg2;
31052   if (!arg2) {
31053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31054     return ;
31055   }
31056   {
31057     try {
31058       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31059     } catch (std::out_of_range& e) {
31060       {
31061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31062       };
31063     } catch (std::exception& e) {
31064       {
31065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31070       };
31071     }
31072   }
31073 }
31074
31075
31076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31077   void * jresult ;
31078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31079   Dali::Vector3 result;
31080
31081   arg1 = (Dali::Actor *)jarg1;
31082   {
31083     try {
31084       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31085     } catch (std::out_of_range& e) {
31086       {
31087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31088       };
31089     } catch (std::exception& e) {
31090       {
31091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31092       };
31093     } catch (...) {
31094       {
31095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31096       };
31097     }
31098   }
31099   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31100   return jresult;
31101 }
31102
31103
31104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31105   void * jresult ;
31106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31107   Dali::Vector3 result;
31108
31109   arg1 = (Dali::Actor *)jarg1;
31110   {
31111     try {
31112       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (...) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31124       };
31125     }
31126   }
31127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31134   bool arg2 ;
31135
31136   arg1 = (Dali::Actor *)jarg1;
31137   arg2 = jarg2 ? true : false;
31138   {
31139     try {
31140       (arg1)->SetInheritScale(arg2);
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (...) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31152       };
31153     }
31154   }
31155 }
31156
31157
31158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31159   unsigned int jresult ;
31160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31161   bool result;
31162
31163   arg1 = (Dali::Actor *)jarg1;
31164   {
31165     try {
31166       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31174       };
31175     } catch (...) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31178       };
31179     }
31180   }
31181   jresult = result;
31182   return jresult;
31183 }
31184
31185
31186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31187   void * jresult ;
31188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31189   Dali::Matrix result;
31190
31191   arg1 = (Dali::Actor *)jarg1;
31192   {
31193     try {
31194       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31202       };
31203     } catch (...) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31206       };
31207     }
31208   }
31209   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31210   return jresult;
31211 }
31212
31213
31214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31216   bool arg2 ;
31217
31218   arg1 = (Dali::Actor *)jarg1;
31219   arg2 = jarg2 ? true : false;
31220   {
31221     try {
31222       (arg1)->SetVisible(arg2);
31223     } catch (std::out_of_range& e) {
31224       {
31225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31226       };
31227     } catch (std::exception& e) {
31228       {
31229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31230       };
31231     } catch (...) {
31232       {
31233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31234       };
31235     }
31236   }
31237 }
31238
31239
31240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31241   unsigned int jresult ;
31242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31243   bool result;
31244
31245   arg1 = (Dali::Actor *)jarg1;
31246   {
31247     try {
31248       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31249     } catch (std::out_of_range& e) {
31250       {
31251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31252       };
31253     } catch (std::exception& e) {
31254       {
31255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31256       };
31257     } catch (...) {
31258       {
31259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31260       };
31261     }
31262   }
31263   jresult = result;
31264   return jresult;
31265 }
31266
31267
31268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31270   float arg2 ;
31271
31272   arg1 = (Dali::Actor *)jarg1;
31273   arg2 = (float)jarg2;
31274   {
31275     try {
31276       (arg1)->SetOpacity(arg2);
31277     } catch (std::out_of_range& e) {
31278       {
31279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31280       };
31281     } catch (std::exception& e) {
31282       {
31283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31284       };
31285     } catch (...) {
31286       {
31287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31288       };
31289     }
31290   }
31291 }
31292
31293
31294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31295   float jresult ;
31296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31297   float result;
31298
31299   arg1 = (Dali::Actor *)jarg1;
31300   {
31301     try {
31302       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31303     } catch (std::out_of_range& e) {
31304       {
31305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31306       };
31307     } catch (std::exception& e) {
31308       {
31309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31310       };
31311     } catch (...) {
31312       {
31313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31314       };
31315     }
31316   }
31317   jresult = result;
31318   return jresult;
31319 }
31320
31321
31322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31324   Dali::Vector4 *arg2 = 0 ;
31325
31326   arg1 = (Dali::Actor *)jarg1;
31327   arg2 = (Dali::Vector4 *)jarg2;
31328   if (!arg2) {
31329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31330     return ;
31331   }
31332   {
31333     try {
31334       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31335     } catch (std::out_of_range& e) {
31336       {
31337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31338       };
31339     } catch (std::exception& e) {
31340       {
31341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31342       };
31343     } catch (...) {
31344       {
31345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31346       };
31347     }
31348   }
31349 }
31350
31351
31352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31353   void * jresult ;
31354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31355   Dali::Vector4 result;
31356
31357   arg1 = (Dali::Actor *)jarg1;
31358   {
31359     try {
31360       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31361     } catch (std::out_of_range& e) {
31362       {
31363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31364       };
31365     } catch (std::exception& e) {
31366       {
31367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (...) {
31370       {
31371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31372       };
31373     }
31374   }
31375   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31376   return jresult;
31377 }
31378
31379
31380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31382   Dali::ColorMode arg2 ;
31383
31384   arg1 = (Dali::Actor *)jarg1;
31385   arg2 = (Dali::ColorMode)jarg2;
31386   {
31387     try {
31388       (arg1)->SetColorMode(arg2);
31389     } catch (std::out_of_range& e) {
31390       {
31391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31392       };
31393     } catch (std::exception& e) {
31394       {
31395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31396       };
31397     } catch (...) {
31398       {
31399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31400       };
31401     }
31402   }
31403 }
31404
31405
31406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31407   int jresult ;
31408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31409   Dali::ColorMode result;
31410
31411   arg1 = (Dali::Actor *)jarg1;
31412   {
31413     try {
31414       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31415     } catch (std::out_of_range& e) {
31416       {
31417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31418       };
31419     } catch (std::exception& e) {
31420       {
31421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31422       };
31423     } catch (...) {
31424       {
31425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31426       };
31427     }
31428   }
31429   jresult = (int)result;
31430   return jresult;
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31435   void * jresult ;
31436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31437   Dali::Vector4 result;
31438
31439   arg1 = (Dali::Actor *)jarg1;
31440   {
31441     try {
31442       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31443     } catch (std::out_of_range& e) {
31444       {
31445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31446       };
31447     } catch (std::exception& e) {
31448       {
31449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (...) {
31452       {
31453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31454       };
31455     }
31456   }
31457   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31464   Dali::DrawMode::Type arg2 ;
31465
31466   arg1 = (Dali::Actor *)jarg1;
31467   arg2 = (Dali::DrawMode::Type)jarg2;
31468   {
31469     try {
31470       (arg1)->SetDrawMode(arg2);
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31482       };
31483     }
31484   }
31485 }
31486
31487
31488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31489   int jresult ;
31490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31491   Dali::DrawMode::Type result;
31492
31493   arg1 = (Dali::Actor *)jarg1;
31494   {
31495     try {
31496       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31497     } catch (std::out_of_range& e) {
31498       {
31499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (std::exception& e) {
31502       {
31503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511   jresult = (int)result;
31512   return jresult;
31513 }
31514
31515
31516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31518   bool arg2 ;
31519
31520   arg1 = (Dali::Actor *)jarg1;
31521   arg2 = jarg2 ? true : false;
31522   {
31523     try {
31524       (arg1)->SetSensitive(arg2);
31525     } catch (std::out_of_range& e) {
31526       {
31527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31528       };
31529     } catch (std::exception& e) {
31530       {
31531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31536       };
31537     }
31538   }
31539 }
31540
31541
31542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31543   unsigned int jresult ;
31544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31545   bool result;
31546
31547   arg1 = (Dali::Actor *)jarg1;
31548   {
31549     try {
31550       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (...) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31562       };
31563     }
31564   }
31565   jresult = result;
31566   return jresult;
31567 }
31568
31569
31570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31571   unsigned int jresult ;
31572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31573   float *arg2 = 0 ;
31574   float *arg3 = 0 ;
31575   float arg4 ;
31576   float arg5 ;
31577   bool result;
31578
31579   arg1 = (Dali::Actor *)jarg1;
31580   arg2 = (float *)jarg2;
31581   arg3 = (float *)jarg3;
31582   arg4 = (float)jarg4;
31583   arg5 = (float)jarg5;
31584   {
31585     try {
31586       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31587     } catch (std::out_of_range& e) {
31588       {
31589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31590       };
31591     } catch (std::exception& e) {
31592       {
31593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31594       };
31595     } catch (...) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31598       };
31599     }
31600   }
31601   jresult = result;
31602   return jresult;
31603 }
31604
31605
31606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31608   bool arg2 ;
31609
31610   arg1 = (Dali::Actor *)jarg1;
31611   arg2 = jarg2 ? true : false;
31612   {
31613     try {
31614       (arg1)->SetLeaveRequired(arg2);
31615     } catch (std::out_of_range& e) {
31616       {
31617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31618       };
31619     } catch (std::exception& e) {
31620       {
31621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31622       };
31623     } catch (...) {
31624       {
31625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31626       };
31627     }
31628   }
31629 }
31630
31631
31632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31633   unsigned int jresult ;
31634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31635   bool result;
31636
31637   arg1 = (Dali::Actor *)jarg1;
31638   {
31639     try {
31640       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (...) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31652       };
31653     }
31654   }
31655   jresult = result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31662   bool arg2 ;
31663
31664   arg1 = (Dali::Actor *)jarg1;
31665   arg2 = jarg2 ? true : false;
31666   {
31667     try {
31668       (arg1)->SetKeyboardFocusable(arg2);
31669     } catch (std::out_of_range& e) {
31670       {
31671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31672       };
31673     } catch (std::exception& e) {
31674       {
31675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31680       };
31681     }
31682   }
31683 }
31684
31685
31686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31687   unsigned int jresult ;
31688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31689   bool result;
31690
31691   arg1 = (Dali::Actor *)jarg1;
31692   {
31693     try {
31694       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31695     } catch (std::out_of_range& e) {
31696       {
31697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (std::exception& e) {
31700       {
31701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709   jresult = result;
31710   return jresult;
31711 }
31712
31713
31714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31716   Dali::ResizePolicy::Type arg2 ;
31717   Dali::Dimension::Type arg3 ;
31718
31719   arg1 = (Dali::Actor *)jarg1;
31720   arg2 = (Dali::ResizePolicy::Type)jarg2;
31721   arg3 = (Dali::Dimension::Type)jarg3;
31722   {
31723     try {
31724       (arg1)->SetResizePolicy(arg2,arg3);
31725     } catch (std::out_of_range& e) {
31726       {
31727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31728       };
31729     } catch (std::exception& e) {
31730       {
31731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31736       };
31737     }
31738   }
31739 }
31740
31741
31742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31743   int jresult ;
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Dimension::Type arg2 ;
31746   Dali::ResizePolicy::Type result;
31747
31748   arg1 = (Dali::Actor *)jarg1;
31749   arg2 = (Dali::Dimension::Type)jarg2;
31750   {
31751     try {
31752       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31753     } catch (std::out_of_range& e) {
31754       {
31755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31756       };
31757     } catch (std::exception& e) {
31758       {
31759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (...) {
31762       {
31763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31764       };
31765     }
31766   }
31767   jresult = (int)result;
31768   return jresult;
31769 }
31770
31771
31772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31774   Dali::SizeScalePolicy::Type arg2 ;
31775
31776   arg1 = (Dali::Actor *)jarg1;
31777   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31778   {
31779     try {
31780       (arg1)->SetSizeScalePolicy(arg2);
31781     } catch (std::out_of_range& e) {
31782       {
31783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31784       };
31785     } catch (std::exception& e) {
31786       {
31787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31788       };
31789     } catch (...) {
31790       {
31791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31792       };
31793     }
31794   }
31795 }
31796
31797
31798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31799   int jresult ;
31800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31801   Dali::SizeScalePolicy::Type result;
31802
31803   arg1 = (Dali::Actor *)jarg1;
31804   {
31805     try {
31806       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31807     } catch (std::out_of_range& e) {
31808       {
31809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (std::exception& e) {
31812       {
31813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821   jresult = (int)result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31828   Dali::Vector3 *arg2 = 0 ;
31829
31830   arg1 = (Dali::Actor *)jarg1;
31831   arg2 = (Dali::Vector3 *)jarg2;
31832   if (!arg2) {
31833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31834     return ;
31835   }
31836   {
31837     try {
31838       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31839     } catch (std::out_of_range& e) {
31840       {
31841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31842       };
31843     } catch (std::exception& e) {
31844       {
31845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31850       };
31851     }
31852   }
31853 }
31854
31855
31856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31857   void * jresult ;
31858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31859   Dali::Vector3 result;
31860
31861   arg1 = (Dali::Actor *)jarg1;
31862   {
31863     try {
31864       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (...) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31876       };
31877     }
31878   }
31879   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31880   return jresult;
31881 }
31882
31883
31884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31885   float jresult ;
31886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31887   float arg2 ;
31888   float result;
31889
31890   arg1 = (Dali::Actor *)jarg1;
31891   arg2 = (float)jarg2;
31892   {
31893     try {
31894       result = (float)(arg1)->GetHeightForWidth(arg2);
31895     } catch (std::out_of_range& e) {
31896       {
31897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (std::exception& e) {
31900       {
31901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31902       };
31903     } catch (...) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31906       };
31907     }
31908   }
31909   jresult = result;
31910   return jresult;
31911 }
31912
31913
31914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31915   float jresult ;
31916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31917   float arg2 ;
31918   float result;
31919
31920   arg1 = (Dali::Actor *)jarg1;
31921   arg2 = (float)jarg2;
31922   {
31923     try {
31924       result = (float)(arg1)->GetWidthForHeight(arg2);
31925     } catch (std::out_of_range& e) {
31926       {
31927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31928       };
31929     } catch (std::exception& e) {
31930       {
31931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31932       };
31933     } catch (...) {
31934       {
31935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31936       };
31937     }
31938   }
31939   jresult = result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31945   float jresult ;
31946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31947   Dali::Dimension::Type arg2 ;
31948   float result;
31949
31950   arg1 = (Dali::Actor *)jarg1;
31951   arg2 = (Dali::Dimension::Type)jarg2;
31952   {
31953     try {
31954       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31955     } catch (std::out_of_range& e) {
31956       {
31957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31958       };
31959     } catch (std::exception& e) {
31960       {
31961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (...) {
31964       {
31965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31966       };
31967     }
31968   }
31969   jresult = result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31976   Dali::Padding *arg2 = 0 ;
31977
31978   arg1 = (Dali::Actor *)jarg1;
31979   arg2 = (Dali::Padding *)jarg2;
31980   if (!arg2) {
31981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31982     return ;
31983   }
31984   {
31985     try {
31986       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31987     } catch (std::out_of_range& e) {
31988       {
31989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31990       };
31991     } catch (std::exception& e) {
31992       {
31993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31994       };
31995     } catch (...) {
31996       {
31997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31998       };
31999     }
32000   }
32001 }
32002
32003
32004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32006   Dali::Padding *arg2 = 0 ;
32007
32008   arg1 = (Dali::Actor *)jarg1;
32009   arg2 = (Dali::Padding *)jarg2;
32010   if (!arg2) {
32011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32012     return ;
32013   }
32014   {
32015     try {
32016       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32017     } catch (std::out_of_range& e) {
32018       {
32019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32020       };
32021     } catch (std::exception& e) {
32022       {
32023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32024       };
32025     } catch (...) {
32026       {
32027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32028       };
32029     }
32030   }
32031 }
32032
32033
32034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32036   Dali::Vector2 *arg2 = 0 ;
32037
32038   arg1 = (Dali::Actor *)jarg1;
32039   arg2 = (Dali::Vector2 *)jarg2;
32040   if (!arg2) {
32041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32042     return ;
32043   }
32044   {
32045     try {
32046       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32047     } catch (std::out_of_range& e) {
32048       {
32049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32050       };
32051     } catch (std::exception& e) {
32052       {
32053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32054       };
32055     } catch (...) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32058       };
32059     }
32060   }
32061 }
32062
32063
32064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32065   void * jresult ;
32066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32067   Dali::Vector2 result;
32068
32069   arg1 = (Dali::Actor *)jarg1;
32070   {
32071     try {
32072       result = (arg1)->GetMinimumSize();
32073     } catch (std::out_of_range& e) {
32074       {
32075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32076       };
32077     } catch (std::exception& e) {
32078       {
32079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32080       };
32081     } catch (...) {
32082       {
32083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32084       };
32085     }
32086   }
32087   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32094   Dali::Vector2 *arg2 = 0 ;
32095
32096   arg1 = (Dali::Actor *)jarg1;
32097   arg2 = (Dali::Vector2 *)jarg2;
32098   if (!arg2) {
32099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32100     return ;
32101   }
32102   {
32103     try {
32104       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32105     } catch (std::out_of_range& e) {
32106       {
32107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32108       };
32109     } catch (std::exception& e) {
32110       {
32111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32112       };
32113     } catch (...) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32116       };
32117     }
32118   }
32119 }
32120
32121
32122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32123   void * jresult ;
32124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32125   Dali::Vector2 result;
32126
32127   arg1 = (Dali::Actor *)jarg1;
32128   {
32129     try {
32130       result = (arg1)->GetMaximumSize();
32131     } catch (std::out_of_range& e) {
32132       {
32133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32134       };
32135     } catch (std::exception& e) {
32136       {
32137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32138       };
32139     } catch (...) {
32140       {
32141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32142       };
32143     }
32144   }
32145   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32146   return jresult;
32147 }
32148
32149
32150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32151   int jresult ;
32152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32153   int result;
32154
32155   arg1 = (Dali::Actor *)jarg1;
32156   {
32157     try {
32158       result = (int)(arg1)->GetHierarchyDepth();
32159     } catch (std::out_of_range& e) {
32160       {
32161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32162       };
32163     } catch (std::exception& e) {
32164       {
32165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32166       };
32167     } catch (...) {
32168       {
32169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32170       };
32171     }
32172   }
32173   jresult = result;
32174   return jresult;
32175 }
32176
32177
32178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32179   unsigned int jresult ;
32180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32181   Dali::Renderer *arg2 = 0 ;
32182   unsigned int result;
32183
32184   arg1 = (Dali::Actor *)jarg1;
32185   arg2 = (Dali::Renderer *)jarg2;
32186   if (!arg2) {
32187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32188     return 0;
32189   }
32190   {
32191     try {
32192       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32193     } catch (std::out_of_range& e) {
32194       {
32195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32196       };
32197     } catch (std::exception& e) {
32198       {
32199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32200       };
32201     } catch (...) {
32202       {
32203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32204       };
32205     }
32206   }
32207   jresult = result;
32208   return jresult;
32209 }
32210
32211
32212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32213   unsigned int jresult ;
32214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32215   unsigned int result;
32216
32217   arg1 = (Dali::Actor *)jarg1;
32218   {
32219     try {
32220       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32221     } catch (std::out_of_range& e) {
32222       {
32223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32224       };
32225     } catch (std::exception& e) {
32226       {
32227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32228       };
32229     } catch (...) {
32230       {
32231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32232       };
32233     }
32234   }
32235   jresult = result;
32236   return jresult;
32237 }
32238
32239
32240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32241   void * jresult ;
32242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32243   unsigned int arg2 ;
32244   Dali::Renderer result;
32245
32246   arg1 = (Dali::Actor *)jarg1;
32247   arg2 = (unsigned int)jarg2;
32248   {
32249     try {
32250       result = (arg1)->GetRendererAt(arg2);
32251     } catch (std::out_of_range& e) {
32252       {
32253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (std::exception& e) {
32256       {
32257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32272   Dali::Renderer *arg2 = 0 ;
32273
32274   arg1 = (Dali::Actor *)jarg1;
32275   arg2 = (Dali::Renderer *)jarg2;
32276   if (!arg2) {
32277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32278     return ;
32279   }
32280   {
32281     try {
32282       (arg1)->RemoveRenderer(*arg2);
32283     } catch (std::out_of_range& e) {
32284       {
32285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32286       };
32287     } catch (std::exception& e) {
32288       {
32289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32294       };
32295     }
32296   }
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32302   unsigned int arg2 ;
32303
32304   arg1 = (Dali::Actor *)jarg1;
32305   arg2 = (unsigned int)jarg2;
32306   {
32307     try {
32308       (arg1)->RemoveRenderer(arg2);
32309     } catch (std::out_of_range& e) {
32310       {
32311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32312       };
32313     } catch (std::exception& e) {
32314       {
32315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32320       };
32321     }
32322   }
32323 }
32324
32325
32326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32327   void * jresult ;
32328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32329   Dali::Actor::TouchSignalType *result = 0 ;
32330
32331   arg1 = (Dali::Actor *)jarg1;
32332   {
32333     try {
32334       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32335     } catch (std::out_of_range& e) {
32336       {
32337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32338       };
32339     } catch (std::exception& e) {
32340       {
32341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32346       };
32347     }
32348   }
32349   jresult = (void *)result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32355   void * jresult ;
32356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32357   Dali::Actor::TouchDataSignalType *result = 0 ;
32358
32359   arg1 = (Dali::Actor *)jarg1;
32360   {
32361     try {
32362       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32363     } catch (std::out_of_range& e) {
32364       {
32365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32366       };
32367     } catch (std::exception& e) {
32368       {
32369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32370       };
32371     } catch (...) {
32372       {
32373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32374       };
32375     }
32376   }
32377   jresult = (void *)result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32383   void * jresult ;
32384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32385   Dali::Actor::HoverSignalType *result = 0 ;
32386
32387   arg1 = (Dali::Actor *)jarg1;
32388   {
32389     try {
32390       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (...) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32402       };
32403     }
32404   }
32405   jresult = (void *)result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32411   void * jresult ;
32412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32413   Dali::Actor::WheelEventSignalType *result = 0 ;
32414
32415   arg1 = (Dali::Actor *)jarg1;
32416   {
32417     try {
32418       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32419     } catch (std::out_of_range& e) {
32420       {
32421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32422       };
32423     } catch (std::exception& e) {
32424       {
32425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32426       };
32427     } catch (...) {
32428       {
32429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32430       };
32431     }
32432   }
32433   jresult = (void *)result;
32434   return jresult;
32435 }
32436
32437
32438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32439   void * jresult ;
32440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32441   Dali::Actor::OnStageSignalType *result = 0 ;
32442
32443   arg1 = (Dali::Actor *)jarg1;
32444   {
32445     try {
32446       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32458       };
32459     }
32460   }
32461   jresult = (void *)result;
32462   return jresult;
32463 }
32464
32465
32466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32467   void * jresult ;
32468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32469   Dali::Actor::OffStageSignalType *result = 0 ;
32470
32471   arg1 = (Dali::Actor *)jarg1;
32472   {
32473     try {
32474       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32475     } catch (std::out_of_range& e) {
32476       {
32477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32478       };
32479     } catch (std::exception& e) {
32480       {
32481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32482       };
32483     } catch (...) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32486       };
32487     }
32488   }
32489   jresult = (void *)result;
32490   return jresult;
32491 }
32492
32493
32494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32495   void * jresult ;
32496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32497   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32498
32499   arg1 = (Dali::Actor *)jarg1;
32500   {
32501     try {
32502       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32503     } catch (std::out_of_range& e) {
32504       {
32505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (std::exception& e) {
32508       {
32509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (...) {
32512       {
32513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32514       };
32515     }
32516   }
32517   jresult = (void *)result;
32518   return jresult;
32519 }
32520
32521
32522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32523   Dali::Actor *arg1 = 0 ;
32524
32525   arg1 = (Dali::Actor *)jarg1;
32526   if (!arg1) {
32527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32528     return ;
32529   }
32530   {
32531     try {
32532       Dali::UnparentAndReset(*arg1);
32533     } catch (std::out_of_range& e) {
32534       {
32535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32536       };
32537     } catch (std::exception& e) {
32538       {
32539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32540       };
32541     } catch (...) {
32542       {
32543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32544       };
32545     }
32546   }
32547 }
32548
32549
32550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32551   int jresult ;
32552   int result;
32553
32554   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32555   jresult = (int)result;
32556   return jresult;
32557 }
32558
32559
32560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32561   int jresult ;
32562   int result;
32563
32564   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32565   jresult = (int)result;
32566   return jresult;
32567 }
32568
32569
32570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32571   int jresult ;
32572   int result;
32573
32574   result = (int)Dali::Layer::Property::BEHAVIOR;
32575   jresult = (int)result;
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32581   void * jresult ;
32582   Dali::Layer::Property *result = 0 ;
32583
32584   {
32585     try {
32586       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32587     } catch (std::out_of_range& e) {
32588       {
32589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32590       };
32591     } catch (std::exception& e) {
32592       {
32593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32594       };
32595     } catch (...) {
32596       {
32597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32598       };
32599     }
32600   }
32601   jresult = (void *)result;
32602   return jresult;
32603 }
32604
32605
32606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32607   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32608
32609   arg1 = (Dali::Layer::Property *)jarg1;
32610   {
32611     try {
32612       delete arg1;
32613     } catch (std::out_of_range& e) {
32614       {
32615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32616       };
32617     } catch (std::exception& e) {
32618       {
32619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32624       };
32625     }
32626   }
32627 }
32628
32629
32630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32631   void * jresult ;
32632   Dali::Layer *result = 0 ;
32633
32634   {
32635     try {
32636       result = (Dali::Layer *)new Dali::Layer();
32637     } catch (std::out_of_range& e) {
32638       {
32639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32640       };
32641     } catch (std::exception& e) {
32642       {
32643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32644       };
32645     } catch (...) {
32646       {
32647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32648       };
32649     }
32650   }
32651   jresult = (void *)result;
32652   return jresult;
32653 }
32654
32655
32656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32657   void * jresult ;
32658   Dali::Layer result;
32659
32660   {
32661     try {
32662       result = Dali::Layer::New();
32663     } catch (std::out_of_range& e) {
32664       {
32665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32666       };
32667     } catch (std::exception& e) {
32668       {
32669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32670       };
32671     } catch (...) {
32672       {
32673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32674       };
32675     }
32676   }
32677   jresult = new Dali::Layer((const Dali::Layer &)result);
32678   return jresult;
32679 }
32680
32681
32682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32683   void * jresult ;
32684   Dali::BaseHandle arg1 ;
32685   Dali::BaseHandle *argp1 ;
32686   Dali::Layer result;
32687
32688   argp1 = (Dali::BaseHandle *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32691     return 0;
32692   }
32693   arg1 = *argp1;
32694   {
32695     try {
32696       result = Dali::Layer::DownCast(arg1);
32697     } catch (std::out_of_range& e) {
32698       {
32699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32700       };
32701     } catch (std::exception& e) {
32702       {
32703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32704       };
32705     } catch (...) {
32706       {
32707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32708       };
32709     }
32710   }
32711   jresult = new Dali::Layer((const Dali::Layer &)result);
32712   return jresult;
32713 }
32714
32715
32716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32718
32719   arg1 = (Dali::Layer *)jarg1;
32720   {
32721     try {
32722       delete arg1;
32723     } catch (std::out_of_range& e) {
32724       {
32725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (std::exception& e) {
32728       {
32729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32734       };
32735     }
32736   }
32737 }
32738
32739
32740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32741   void * jresult ;
32742   Dali::Layer *arg1 = 0 ;
32743   Dali::Layer *result = 0 ;
32744
32745   arg1 = (Dali::Layer *)jarg1;
32746   if (!arg1) {
32747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32748     return 0;
32749   }
32750   {
32751     try {
32752       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32760       };
32761     } catch (...) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32764       };
32765     }
32766   }
32767   jresult = (void *)result;
32768   return jresult;
32769 }
32770
32771
32772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32773   void * jresult ;
32774   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32775   Dali::Layer *arg2 = 0 ;
32776   Dali::Layer *result = 0 ;
32777
32778   arg1 = (Dali::Layer *)jarg1;
32779   arg2 = (Dali::Layer *)jarg2;
32780   if (!arg2) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32782     return 0;
32783   }
32784   {
32785     try {
32786       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32787     } catch (std::out_of_range& e) {
32788       {
32789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (std::exception& e) {
32792       {
32793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801   jresult = (void *)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32807   unsigned int jresult ;
32808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32809   unsigned int result;
32810
32811   arg1 = (Dali::Layer *)jarg1;
32812   {
32813     try {
32814       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (...) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32826       };
32827     }
32828   }
32829   jresult = result;
32830   return jresult;
32831 }
32832
32833
32834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32835   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32836
32837   arg1 = (Dali::Layer *)jarg1;
32838   {
32839     try {
32840       (arg1)->Raise();
32841     } catch (std::out_of_range& e) {
32842       {
32843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (std::exception& e) {
32846       {
32847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855 }
32856
32857
32858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32859   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32860
32861   arg1 = (Dali::Layer *)jarg1;
32862   {
32863     try {
32864       (arg1)->Lower();
32865     } catch (std::out_of_range& e) {
32866       {
32867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32868       };
32869     } catch (std::exception& e) {
32870       {
32871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32872       };
32873     } catch (...) {
32874       {
32875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32876       };
32877     }
32878   }
32879 }
32880
32881
32882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32883   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32884   Dali::Layer arg2 ;
32885   Dali::Layer *argp2 ;
32886
32887   arg1 = (Dali::Layer *)jarg1;
32888   argp2 = (Dali::Layer *)jarg2;
32889   if (!argp2) {
32890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32891     return ;
32892   }
32893   arg2 = *argp2;
32894   {
32895     try {
32896       (arg1)->RaiseAbove(arg2);
32897     } catch (std::out_of_range& e) {
32898       {
32899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32900       };
32901     } catch (std::exception& e) {
32902       {
32903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32904       };
32905     } catch (...) {
32906       {
32907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32908       };
32909     }
32910   }
32911 }
32912
32913
32914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32915   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32916   Dali::Layer arg2 ;
32917   Dali::Layer *argp2 ;
32918
32919   arg1 = (Dali::Layer *)jarg1;
32920   argp2 = (Dali::Layer *)jarg2;
32921   if (!argp2) {
32922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32923     return ;
32924   }
32925   arg2 = *argp2;
32926   {
32927     try {
32928       (arg1)->LowerBelow(arg2);
32929     } catch (std::out_of_range& e) {
32930       {
32931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32932       };
32933     } catch (std::exception& e) {
32934       {
32935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32936       };
32937     } catch (...) {
32938       {
32939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32940       };
32941     }
32942   }
32943 }
32944
32945
32946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32947   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32948
32949   arg1 = (Dali::Layer *)jarg1;
32950   {
32951     try {
32952       (arg1)->RaiseToTop();
32953     } catch (std::out_of_range& e) {
32954       {
32955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32956       };
32957     } catch (std::exception& e) {
32958       {
32959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32960       };
32961     } catch (...) {
32962       {
32963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32964       };
32965     }
32966   }
32967 }
32968
32969
32970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32971   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32972
32973   arg1 = (Dali::Layer *)jarg1;
32974   {
32975     try {
32976       (arg1)->LowerToBottom();
32977     } catch (std::out_of_range& e) {
32978       {
32979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32980       };
32981     } catch (std::exception& e) {
32982       {
32983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32984       };
32985     } catch (...) {
32986       {
32987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32988       };
32989     }
32990   }
32991 }
32992
32993
32994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32995   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32996   Dali::Layer arg2 ;
32997   Dali::Layer *argp2 ;
32998
32999   arg1 = (Dali::Layer *)jarg1;
33000   argp2 = (Dali::Layer *)jarg2;
33001   if (!argp2) {
33002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33003     return ;
33004   }
33005   arg2 = *argp2;
33006   {
33007     try {
33008       (arg1)->MoveAbove(arg2);
33009     } catch (std::out_of_range& e) {
33010       {
33011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33012       };
33013     } catch (std::exception& e) {
33014       {
33015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33016       };
33017     } catch (...) {
33018       {
33019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33020       };
33021     }
33022   }
33023 }
33024
33025
33026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33027   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33028   Dali::Layer arg2 ;
33029   Dali::Layer *argp2 ;
33030
33031   arg1 = (Dali::Layer *)jarg1;
33032   argp2 = (Dali::Layer *)jarg2;
33033   if (!argp2) {
33034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33035     return ;
33036   }
33037   arg2 = *argp2;
33038   {
33039     try {
33040       (arg1)->MoveBelow(arg2);
33041     } catch (std::out_of_range& e) {
33042       {
33043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33044       };
33045     } catch (std::exception& e) {
33046       {
33047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33048       };
33049     } catch (...) {
33050       {
33051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33052       };
33053     }
33054   }
33055 }
33056
33057
33058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33059   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33060   Dali::Layer::Behavior arg2 ;
33061
33062   arg1 = (Dali::Layer *)jarg1;
33063   arg2 = (Dali::Layer::Behavior)jarg2;
33064   {
33065     try {
33066       (arg1)->SetBehavior(arg2);
33067     } catch (std::out_of_range& e) {
33068       {
33069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33070       };
33071     } catch (std::exception& e) {
33072       {
33073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33074       };
33075     } catch (...) {
33076       {
33077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33078       };
33079     }
33080   }
33081 }
33082
33083
33084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33085   int jresult ;
33086   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33087   Dali::Layer::Behavior result;
33088
33089   arg1 = (Dali::Layer *)jarg1;
33090   {
33091     try {
33092       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33093     } catch (std::out_of_range& e) {
33094       {
33095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33096       };
33097     } catch (std::exception& e) {
33098       {
33099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33100       };
33101     } catch (...) {
33102       {
33103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33104       };
33105     }
33106   }
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33113   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33114   bool arg2 ;
33115
33116   arg1 = (Dali::Layer *)jarg1;
33117   arg2 = jarg2 ? true : false;
33118   {
33119     try {
33120       (arg1)->SetClipping(arg2);
33121     } catch (std::out_of_range& e) {
33122       {
33123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33124       };
33125     } catch (std::exception& e) {
33126       {
33127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33128       };
33129     } catch (...) {
33130       {
33131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33132       };
33133     }
33134   }
33135 }
33136
33137
33138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33139   unsigned int jresult ;
33140   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33141   bool result;
33142
33143   arg1 = (Dali::Layer *)jarg1;
33144   {
33145     try {
33146       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33147     } catch (std::out_of_range& e) {
33148       {
33149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33150       };
33151     } catch (std::exception& e) {
33152       {
33153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33154       };
33155     } catch (...) {
33156       {
33157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33158       };
33159     }
33160   }
33161   jresult = result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33167   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33168   int arg2 ;
33169   int arg3 ;
33170   int arg4 ;
33171   int arg5 ;
33172
33173   arg1 = (Dali::Layer *)jarg1;
33174   arg2 = (int)jarg2;
33175   arg3 = (int)jarg3;
33176   arg4 = (int)jarg4;
33177   arg5 = (int)jarg5;
33178   {
33179     try {
33180       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33181     } catch (std::out_of_range& e) {
33182       {
33183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33184       };
33185     } catch (std::exception& e) {
33186       {
33187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33188       };
33189     } catch (...) {
33190       {
33191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33192       };
33193     }
33194   }
33195 }
33196
33197
33198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33199   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33200   Dali::ClippingBox arg2 ;
33201   Dali::ClippingBox *argp2 ;
33202
33203   arg1 = (Dali::Layer *)jarg1;
33204   argp2 = (Dali::ClippingBox *)jarg2;
33205   if (!argp2) {
33206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33207     return ;
33208   }
33209   arg2 = *argp2;
33210   {
33211     try {
33212       (arg1)->SetClippingBox(arg2);
33213     } catch (std::out_of_range& e) {
33214       {
33215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33216       };
33217     } catch (std::exception& e) {
33218       {
33219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33220       };
33221     } catch (...) {
33222       {
33223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33224       };
33225     }
33226   }
33227 }
33228
33229
33230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33231   void * jresult ;
33232   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33233   Dali::ClippingBox result;
33234
33235   arg1 = (Dali::Layer *)jarg1;
33236   {
33237     try {
33238       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33239     } catch (std::out_of_range& e) {
33240       {
33241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33242       };
33243     } catch (std::exception& e) {
33244       {
33245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33246       };
33247     } catch (...) {
33248       {
33249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33250       };
33251     }
33252   }
33253   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33259   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33260   bool arg2 ;
33261
33262   arg1 = (Dali::Layer *)jarg1;
33263   arg2 = jarg2 ? true : false;
33264   {
33265     try {
33266       (arg1)->SetDepthTestDisabled(arg2);
33267     } catch (std::out_of_range& e) {
33268       {
33269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33270       };
33271     } catch (std::exception& e) {
33272       {
33273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33274       };
33275     } catch (...) {
33276       {
33277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33278       };
33279     }
33280   }
33281 }
33282
33283
33284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33285   unsigned int jresult ;
33286   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33287   bool result;
33288
33289   arg1 = (Dali::Layer *)jarg1;
33290   {
33291     try {
33292       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33293     } catch (std::out_of_range& e) {
33294       {
33295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (std::exception& e) {
33298       {
33299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33300       };
33301     } catch (...) {
33302       {
33303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33304       };
33305     }
33306   }
33307   jresult = result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33313   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33314   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33315
33316   arg1 = (Dali::Layer *)jarg1;
33317   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33318   {
33319     try {
33320       (arg1)->SetSortFunction(arg2);
33321     } catch (std::out_of_range& e) {
33322       {
33323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33324       };
33325     } catch (std::exception& e) {
33326       {
33327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33328       };
33329     } catch (...) {
33330       {
33331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33332       };
33333     }
33334   }
33335 }
33336
33337
33338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33339   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33340   bool arg2 ;
33341
33342   arg1 = (Dali::Layer *)jarg1;
33343   arg2 = jarg2 ? true : false;
33344   {
33345     try {
33346       (arg1)->SetTouchConsumed(arg2);
33347     } catch (std::out_of_range& e) {
33348       {
33349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33350       };
33351     } catch (std::exception& e) {
33352       {
33353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33354       };
33355     } catch (...) {
33356       {
33357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33358       };
33359     }
33360   }
33361 }
33362
33363
33364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33365   unsigned int jresult ;
33366   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33367   bool result;
33368
33369   arg1 = (Dali::Layer *)jarg1;
33370   {
33371     try {
33372       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33373     } catch (std::out_of_range& e) {
33374       {
33375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (std::exception& e) {
33378       {
33379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387   jresult = result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33393   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33394   bool arg2 ;
33395
33396   arg1 = (Dali::Layer *)jarg1;
33397   arg2 = jarg2 ? true : false;
33398   {
33399     try {
33400       (arg1)->SetHoverConsumed(arg2);
33401     } catch (std::out_of_range& e) {
33402       {
33403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33404       };
33405     } catch (std::exception& e) {
33406       {
33407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33408       };
33409     } catch (...) {
33410       {
33411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33412       };
33413     }
33414   }
33415 }
33416
33417
33418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33419   unsigned int jresult ;
33420   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33421   bool result;
33422
33423   arg1 = (Dali::Layer *)jarg1;
33424   {
33425     try {
33426       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33427     } catch (std::out_of_range& e) {
33428       {
33429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33430       };
33431     } catch (std::exception& e) {
33432       {
33433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (...) {
33436       {
33437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33438       };
33439     }
33440   }
33441   jresult = result;
33442   return jresult;
33443 }
33444
33445
33446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33447   void * jresult ;
33448   Dali::Vector4 *result = 0 ;
33449
33450   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33451   jresult = (void *)result;
33452   return jresult;
33453 }
33454
33455
33456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33457   void * jresult ;
33458   Dali::Vector4 *result = 0 ;
33459
33460   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33461   jresult = (void *)result;
33462   return jresult;
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33467   void * jresult ;
33468   Dali::Stage *result = 0 ;
33469
33470   {
33471     try {
33472       result = (Dali::Stage *)new Dali::Stage();
33473     } catch (std::out_of_range& e) {
33474       {
33475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (std::exception& e) {
33478       {
33479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33493   void * jresult ;
33494   Dali::Stage result;
33495
33496   {
33497     try {
33498       result = Dali::Stage::GetCurrent();
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (...) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33510       };
33511     }
33512   }
33513   jresult = new Dali::Stage((const Dali::Stage &)result);
33514   return jresult;
33515 }
33516
33517
33518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33519   unsigned int jresult ;
33520   bool result;
33521
33522   {
33523     try {
33524       result = (bool)Dali::Stage::IsInstalled();
33525     } catch (std::out_of_range& e) {
33526       {
33527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33528       };
33529     } catch (std::exception& e) {
33530       {
33531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33532       };
33533     } catch (...) {
33534       {
33535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33536       };
33537     }
33538   }
33539   jresult = result;
33540   return jresult;
33541 }
33542
33543
33544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33545   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33546
33547   arg1 = (Dali::Stage *)jarg1;
33548   {
33549     try {
33550       delete arg1;
33551     } catch (std::out_of_range& e) {
33552       {
33553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (std::exception& e) {
33556       {
33557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33562       };
33563     }
33564   }
33565 }
33566
33567
33568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33569   void * jresult ;
33570   Dali::Stage *arg1 = 0 ;
33571   Dali::Stage *result = 0 ;
33572
33573   arg1 = (Dali::Stage *)jarg1;
33574   if (!arg1) {
33575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33576     return 0;
33577   }
33578   {
33579     try {
33580       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33581     } catch (std::out_of_range& e) {
33582       {
33583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (std::exception& e) {
33586       {
33587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595   jresult = (void *)result;
33596   return jresult;
33597 }
33598
33599
33600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33601   void * jresult ;
33602   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33603   Dali::Stage *arg2 = 0 ;
33604   Dali::Stage *result = 0 ;
33605
33606   arg1 = (Dali::Stage *)jarg1;
33607   arg2 = (Dali::Stage *)jarg2;
33608   if (!arg2) {
33609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33610     return 0;
33611   }
33612   {
33613     try {
33614       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33615     } catch (std::out_of_range& e) {
33616       {
33617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (std::exception& e) {
33620       {
33621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629   jresult = (void *)result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33636   Dali::Actor *arg2 = 0 ;
33637
33638   arg1 = (Dali::Stage *)jarg1;
33639   arg2 = (Dali::Actor *)jarg2;
33640   if (!arg2) {
33641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33642     return ;
33643   }
33644   {
33645     try {
33646       (arg1)->Add(*arg2);
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33658       };
33659     }
33660   }
33661 }
33662
33663
33664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33665   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33666   Dali::Actor *arg2 = 0 ;
33667
33668   arg1 = (Dali::Stage *)jarg1;
33669   arg2 = (Dali::Actor *)jarg2;
33670   if (!arg2) {
33671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33672     return ;
33673   }
33674   {
33675     try {
33676       (arg1)->Remove(*arg2);
33677     } catch (std::out_of_range& e) {
33678       {
33679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33680       };
33681     } catch (std::exception& e) {
33682       {
33683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33688       };
33689     }
33690   }
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33695   void * jresult ;
33696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33697   Dali::Vector2 result;
33698
33699   arg1 = (Dali::Stage *)jarg1;
33700   {
33701     try {
33702       result = ((Dali::Stage const *)arg1)->GetSize();
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33714       };
33715     }
33716   }
33717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33718   return jresult;
33719 }
33720
33721
33722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33723   void * jresult ;
33724   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33725   Dali::RenderTaskList result;
33726
33727   arg1 = (Dali::Stage *)jarg1;
33728   {
33729     try {
33730       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33731     } catch (std::out_of_range& e) {
33732       {
33733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (std::exception& e) {
33736       {
33737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33742       };
33743     }
33744   }
33745   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33746   return jresult;
33747 }
33748
33749
33750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33751   unsigned int jresult ;
33752   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33753   unsigned int result;
33754
33755   arg1 = (Dali::Stage *)jarg1;
33756   {
33757     try {
33758       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33759     } catch (std::out_of_range& e) {
33760       {
33761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33762       };
33763     } catch (std::exception& e) {
33764       {
33765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33770       };
33771     }
33772   }
33773   jresult = result;
33774   return jresult;
33775 }
33776
33777
33778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33779   void * jresult ;
33780   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33781   unsigned int arg2 ;
33782   Dali::Layer result;
33783
33784   arg1 = (Dali::Stage *)jarg1;
33785   arg2 = (unsigned int)jarg2;
33786   {
33787     try {
33788       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803   jresult = new Dali::Layer((const Dali::Layer &)result);
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33809   void * jresult ;
33810   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33811   Dali::Layer result;
33812
33813   arg1 = (Dali::Stage *)jarg1;
33814   {
33815     try {
33816       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (...) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33828       };
33829     }
33830   }
33831   jresult = new Dali::Layer((const Dali::Layer &)result);
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33838   Dali::Vector4 arg2 ;
33839   Dali::Vector4 *argp2 ;
33840
33841   arg1 = (Dali::Stage *)jarg1;
33842   argp2 = (Dali::Vector4 *)jarg2;
33843   if (!argp2) {
33844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33845     return ;
33846   }
33847   arg2 = *argp2;
33848   {
33849     try {
33850       (arg1)->SetBackgroundColor(arg2);
33851     } catch (std::out_of_range& e) {
33852       {
33853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33854       };
33855     } catch (std::exception& e) {
33856       {
33857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33862       };
33863     }
33864   }
33865 }
33866
33867
33868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33869   void * jresult ;
33870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33871   Dali::Vector4 result;
33872
33873   arg1 = (Dali::Stage *)jarg1;
33874   {
33875     try {
33876       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33888       };
33889     }
33890   }
33891   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33897   void * jresult ;
33898   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33899   Dali::Vector2 result;
33900
33901   arg1 = (Dali::Stage *)jarg1;
33902   {
33903     try {
33904       result = ((Dali::Stage const *)arg1)->GetDpi();
33905     } catch (std::out_of_range& e) {
33906       {
33907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33908       };
33909     } catch (std::exception& e) {
33910       {
33911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33912       };
33913     } catch (...) {
33914       {
33915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33916       };
33917     }
33918   }
33919   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33920   return jresult;
33921 }
33922
33923
33924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33925   void * jresult ;
33926   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33927   Dali::ObjectRegistry result;
33928
33929   arg1 = (Dali::Stage *)jarg1;
33930   {
33931     try {
33932       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33933     } catch (std::out_of_range& e) {
33934       {
33935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33936       };
33937     } catch (std::exception& e) {
33938       {
33939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33940       };
33941     } catch (...) {
33942       {
33943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33944       };
33945     }
33946   }
33947   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33948   return jresult;
33949 }
33950
33951
33952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33953   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33954   float arg2 ;
33955
33956   arg1 = (Dali::Stage *)jarg1;
33957   arg2 = (float)jarg2;
33958   {
33959     try {
33960       (arg1)->KeepRendering(arg2);
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33968       };
33969     } catch (...) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33972       };
33973     }
33974   }
33975 }
33976
33977
33978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33979   void * jresult ;
33980   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33981   Dali::Stage::KeyEventSignalType *result = 0 ;
33982
33983   arg1 = (Dali::Stage *)jarg1;
33984   {
33985     try {
33986       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33987     } catch (std::out_of_range& e) {
33988       {
33989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33990       };
33991     } catch (std::exception& e) {
33992       {
33993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (...) {
33996       {
33997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33998       };
33999     }
34000   }
34001   jresult = (void *)result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34007   void * jresult ;
34008   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34009   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34010
34011   arg1 = (Dali::Stage *)jarg1;
34012   {
34013     try {
34014       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (...) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34026       };
34027     }
34028   }
34029   jresult = (void *)result;
34030   return jresult;
34031 }
34032
34033
34034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34035   void * jresult ;
34036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34037   Dali::Stage::TouchSignalType *result = 0 ;
34038
34039   arg1 = (Dali::Stage *)jarg1;
34040   {
34041     try {
34042       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34043     } catch (std::out_of_range& e) {
34044       {
34045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34046       };
34047     } catch (std::exception& e) {
34048       {
34049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34050       };
34051     } catch (...) {
34052       {
34053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34054       };
34055     }
34056   }
34057   jresult = (void *)result;
34058   return jresult;
34059 }
34060
34061
34062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34063   void * jresult ;
34064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34065   Dali::Stage::WheelEventSignalType *result = 0 ;
34066
34067   arg1 = (Dali::Stage *)jarg1;
34068   {
34069     try {
34070       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34071     } catch (std::out_of_range& e) {
34072       {
34073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (std::exception& e) {
34076       {
34077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085   jresult = (void *)result;
34086   return jresult;
34087 }
34088
34089
34090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34091   void * jresult ;
34092   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34093   Dali::Stage::ContextStatusSignal *result = 0 ;
34094
34095   arg1 = (Dali::Stage *)jarg1;
34096   {
34097     try {
34098       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34110       };
34111     }
34112   }
34113   jresult = (void *)result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34119   void * jresult ;
34120   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34121   Dali::Stage::ContextStatusSignal *result = 0 ;
34122
34123   arg1 = (Dali::Stage *)jarg1;
34124   {
34125     try {
34126       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (...) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34138       };
34139     }
34140   }
34141   jresult = (void *)result;
34142   return jresult;
34143 }
34144
34145
34146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34147   void * jresult ;
34148   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34149   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34150
34151   arg1 = (Dali::Stage *)jarg1;
34152   {
34153     try {
34154       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34155     } catch (std::out_of_range& e) {
34156       {
34157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (std::exception& e) {
34160       {
34161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169   jresult = (void *)result;
34170   return jresult;
34171 }
34172
34173
34174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34175   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34176
34177   arg1 = (Dali::RelayoutContainer *)jarg1;
34178   {
34179     try {
34180       delete arg1;
34181     } catch (std::out_of_range& e) {
34182       {
34183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34184       };
34185     } catch (std::exception& e) {
34186       {
34187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34188       };
34189     } catch (...) {
34190       {
34191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34192       };
34193     }
34194   }
34195 }
34196
34197
34198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34199   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34200   Dali::Actor *arg2 = 0 ;
34201   Dali::Vector2 *arg3 = 0 ;
34202
34203   arg1 = (Dali::RelayoutContainer *)jarg1;
34204   arg2 = (Dali::Actor *)jarg2;
34205   if (!arg2) {
34206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34207     return ;
34208   }
34209   arg3 = (Dali::Vector2 *)jarg3;
34210   if (!arg3) {
34211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34212     return ;
34213   }
34214   {
34215     try {
34216       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34217     } catch (std::out_of_range& e) {
34218       {
34219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34220       };
34221     } catch (std::exception& e) {
34222       {
34223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34224       };
34225     } catch (...) {
34226       {
34227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34228       };
34229     }
34230   }
34231 }
34232
34233
34234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34235   void * jresult ;
34236   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34237   Dali::CustomActor result;
34238
34239   arg1 = (Dali::CustomActorImpl *)jarg1;
34240   {
34241     try {
34242       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34250       };
34251     } catch (...) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34254       };
34255     }
34256   }
34257   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34258   return jresult;
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34263   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34264   int arg2 ;
34265
34266   arg1 = (Dali::CustomActorImpl *)jarg1;
34267   arg2 = (int)jarg2;
34268   {
34269     try {
34270       (arg1)->OnStageConnection(arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285 }
34286
34287
34288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34290
34291   arg1 = (Dali::CustomActorImpl *)jarg1;
34292   {
34293     try {
34294       (arg1)->OnStageDisconnection();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34302       };
34303     } catch (...) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34306       };
34307     }
34308   }
34309 }
34310
34311
34312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34313   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34314   Dali::Actor *arg2 = 0 ;
34315
34316   arg1 = (Dali::CustomActorImpl *)jarg1;
34317   arg2 = (Dali::Actor *)jarg2;
34318   if (!arg2) {
34319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34320     return ;
34321   }
34322   {
34323     try {
34324       (arg1)->OnChildAdd(*arg2);
34325     } catch (std::out_of_range& e) {
34326       {
34327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34328       };
34329     } catch (std::exception& e) {
34330       {
34331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34332       };
34333     } catch (...) {
34334       {
34335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34336       };
34337     }
34338   }
34339 }
34340
34341
34342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34344   Dali::Actor *arg2 = 0 ;
34345
34346   arg1 = (Dali::CustomActorImpl *)jarg1;
34347   arg2 = (Dali::Actor *)jarg2;
34348   if (!arg2) {
34349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34350     return ;
34351   }
34352   {
34353     try {
34354       (arg1)->OnChildRemove(*arg2);
34355     } catch (std::out_of_range& e) {
34356       {
34357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34358       };
34359     } catch (std::exception& e) {
34360       {
34361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34362       };
34363     } catch (...) {
34364       {
34365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34366       };
34367     }
34368   }
34369 }
34370
34371
34372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34374   Dali::Property::Index arg2 ;
34375   Dali::Property::Value arg3 ;
34376   Dali::Property::Value *argp3 ;
34377
34378   arg1 = (Dali::CustomActorImpl *)jarg1;
34379   arg2 = (Dali::Property::Index)jarg2;
34380   argp3 = (Dali::Property::Value *)jarg3;
34381   if (!argp3) {
34382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34383     return ;
34384   }
34385   arg3 = *argp3;
34386   {
34387     try {
34388       (arg1)->OnPropertySet(arg2,arg3);
34389     } catch (std::out_of_range& e) {
34390       {
34391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (std::exception& e) {
34394       {
34395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (...) {
34398       {
34399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34400       };
34401     }
34402   }
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34408   Dali::Vector3 *arg2 = 0 ;
34409
34410   arg1 = (Dali::CustomActorImpl *)jarg1;
34411   arg2 = (Dali::Vector3 *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34414     return ;
34415   }
34416   {
34417     try {
34418       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34426       };
34427     } catch (...) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34430       };
34431     }
34432   }
34433 }
34434
34435
34436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34437   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34438   Dali::Animation *arg2 = 0 ;
34439   Dali::Vector3 *arg3 = 0 ;
34440
34441   arg1 = (Dali::CustomActorImpl *)jarg1;
34442   arg2 = (Dali::Animation *)jarg2;
34443   if (!arg2) {
34444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34445     return ;
34446   }
34447   arg3 = (Dali::Vector3 *)jarg3;
34448   if (!arg3) {
34449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34450     return ;
34451   }
34452   {
34453     try {
34454       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34455     } catch (std::out_of_range& e) {
34456       {
34457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34458       };
34459     } catch (std::exception& e) {
34460       {
34461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34462       };
34463     } catch (...) {
34464       {
34465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34466       };
34467     }
34468   }
34469 }
34470
34471
34472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34473   unsigned int jresult ;
34474   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34475   Dali::TouchEvent *arg2 = 0 ;
34476   bool result;
34477
34478   arg1 = (Dali::CustomActorImpl *)jarg1;
34479   arg2 = (Dali::TouchEvent *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34482     return 0;
34483   }
34484   {
34485     try {
34486       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34507   unsigned int jresult ;
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::HoverEvent *arg2 = 0 ;
34510   bool result;
34511
34512   arg1 = (Dali::CustomActorImpl *)jarg1;
34513   arg2 = (Dali::HoverEvent *)jarg2;
34514   if (!arg2) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34516     return 0;
34517   }
34518   {
34519     try {
34520       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34528       };
34529     } catch (...) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34532       };
34533     }
34534   }
34535   jresult = result;
34536   return jresult;
34537 }
34538
34539
34540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34541   unsigned int jresult ;
34542   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34543   Dali::KeyEvent *arg2 = 0 ;
34544   bool result;
34545
34546   arg1 = (Dali::CustomActorImpl *)jarg1;
34547   arg2 = (Dali::KeyEvent *)jarg2;
34548   if (!arg2) {
34549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34550     return 0;
34551   }
34552   {
34553     try {
34554       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34555     } catch (std::out_of_range& e) {
34556       {
34557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34558       };
34559     } catch (std::exception& e) {
34560       {
34561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34562       };
34563     } catch (...) {
34564       {
34565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34566       };
34567     }
34568   }
34569   jresult = result;
34570   return jresult;
34571 }
34572
34573
34574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34575   unsigned int jresult ;
34576   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34577   Dali::WheelEvent *arg2 = 0 ;
34578   bool result;
34579
34580   arg1 = (Dali::CustomActorImpl *)jarg1;
34581   arg2 = (Dali::WheelEvent *)jarg2;
34582   if (!arg2) {
34583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34584     return 0;
34585   }
34586   {
34587     try {
34588       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34589     } catch (std::out_of_range& e) {
34590       {
34591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34592       };
34593     } catch (std::exception& e) {
34594       {
34595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (...) {
34598       {
34599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34600       };
34601     }
34602   }
34603   jresult = result;
34604   return jresult;
34605 }
34606
34607
34608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34609   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34610   Dali::Vector2 *arg2 = 0 ;
34611   Dali::RelayoutContainer *arg3 = 0 ;
34612
34613   arg1 = (Dali::CustomActorImpl *)jarg1;
34614   arg2 = (Dali::Vector2 *)jarg2;
34615   if (!arg2) {
34616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34617     return ;
34618   }
34619   arg3 = (Dali::RelayoutContainer *)jarg3;
34620   if (!arg3) {
34621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34622     return ;
34623   }
34624   {
34625     try {
34626       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34627     } catch (std::out_of_range& e) {
34628       {
34629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34630       };
34631     } catch (std::exception& e) {
34632       {
34633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34634       };
34635     } catch (...) {
34636       {
34637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34638       };
34639     }
34640   }
34641 }
34642
34643
34644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34646   Dali::ResizePolicy::Type arg2 ;
34647   Dali::Dimension::Type arg3 ;
34648
34649   arg1 = (Dali::CustomActorImpl *)jarg1;
34650   arg2 = (Dali::ResizePolicy::Type)jarg2;
34651   arg3 = (Dali::Dimension::Type)jarg3;
34652   {
34653     try {
34654       (arg1)->OnSetResizePolicy(arg2,arg3);
34655     } catch (std::out_of_range& e) {
34656       {
34657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34658       };
34659     } catch (std::exception& e) {
34660       {
34661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34662       };
34663     } catch (...) {
34664       {
34665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34666       };
34667     }
34668   }
34669 }
34670
34671
34672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34673   void * jresult ;
34674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34675   Dali::Vector3 result;
34676
34677   arg1 = (Dali::CustomActorImpl *)jarg1;
34678   {
34679     try {
34680       result = (arg1)->GetNaturalSize();
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34688       };
34689     } catch (...) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34692       };
34693     }
34694   }
34695   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34696   return jresult;
34697 }
34698
34699
34700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34701   float jresult ;
34702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34703   Dali::Actor *arg2 = 0 ;
34704   Dali::Dimension::Type arg3 ;
34705   float result;
34706
34707   arg1 = (Dali::CustomActorImpl *)jarg1;
34708   arg2 = (Dali::Actor *)jarg2;
34709   if (!arg2) {
34710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34711     return 0;
34712   }
34713   arg3 = (Dali::Dimension::Type)jarg3;
34714   {
34715     try {
34716       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34717     } catch (std::out_of_range& e) {
34718       {
34719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34720       };
34721     } catch (std::exception& e) {
34722       {
34723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34724       };
34725     } catch (...) {
34726       {
34727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34728       };
34729     }
34730   }
34731   jresult = result;
34732   return jresult;
34733 }
34734
34735
34736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34737   float jresult ;
34738   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34739   float arg2 ;
34740   float result;
34741
34742   arg1 = (Dali::CustomActorImpl *)jarg1;
34743   arg2 = (float)jarg2;
34744   {
34745     try {
34746       result = (float)(arg1)->GetHeightForWidth(arg2);
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34758       };
34759     }
34760   }
34761   jresult = result;
34762   return jresult;
34763 }
34764
34765
34766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34767   float jresult ;
34768   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34769   float arg2 ;
34770   float result;
34771
34772   arg1 = (Dali::CustomActorImpl *)jarg1;
34773   arg2 = (float)jarg2;
34774   {
34775     try {
34776       result = (float)(arg1)->GetWidthForHeight(arg2);
34777     } catch (std::out_of_range& e) {
34778       {
34779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34780       };
34781     } catch (std::exception& e) {
34782       {
34783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34784       };
34785     } catch (...) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34788       };
34789     }
34790   }
34791   jresult = result;
34792   return jresult;
34793 }
34794
34795
34796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34797   unsigned int jresult ;
34798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34799   Dali::Dimension::Type arg2 ;
34800   bool result;
34801
34802   arg1 = (Dali::CustomActorImpl *)jarg1;
34803   arg2 = (Dali::Dimension::Type)jarg2;
34804   {
34805     try {
34806       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34818       };
34819     }
34820   }
34821   jresult = result;
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34827   unsigned int jresult ;
34828   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34829   bool result;
34830
34831   arg1 = (Dali::CustomActorImpl *)jarg1;
34832   {
34833     try {
34834       result = (bool)(arg1)->RelayoutDependentOnChildren();
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34842       };
34843     } catch (...) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34846       };
34847     }
34848   }
34849   jresult = result;
34850   return jresult;
34851 }
34852
34853
34854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34856   Dali::Dimension::Type arg2 ;
34857
34858   arg1 = (Dali::CustomActorImpl *)jarg1;
34859   arg2 = (Dali::Dimension::Type)jarg2;
34860   {
34861     try {
34862       (arg1)->OnCalculateRelayoutSize(arg2);
34863     } catch (std::out_of_range& e) {
34864       {
34865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34866       };
34867     } catch (std::exception& e) {
34868       {
34869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34874       };
34875     }
34876   }
34877 }
34878
34879
34880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34882   float arg2 ;
34883   Dali::Dimension::Type arg3 ;
34884
34885   arg1 = (Dali::CustomActorImpl *)jarg1;
34886   arg2 = (float)jarg2;
34887   arg3 = (Dali::Dimension::Type)jarg3;
34888   {
34889     try {
34890       (arg1)->OnLayoutNegotiated(arg2,arg3);
34891     } catch (std::out_of_range& e) {
34892       {
34893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34894       };
34895     } catch (std::exception& e) {
34896       {
34897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34898       };
34899     } catch (...) {
34900       {
34901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34902       };
34903     }
34904   }
34905 }
34906
34907
34908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34909   unsigned int jresult ;
34910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34911   bool result;
34912
34913   arg1 = (Dali::CustomActorImpl *)jarg1;
34914   {
34915     try {
34916       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34917     } catch (std::out_of_range& e) {
34918       {
34919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (std::exception& e) {
34922       {
34923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34924       };
34925     } catch (...) {
34926       {
34927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34928       };
34929     }
34930   }
34931   jresult = result;
34932   return jresult;
34933 }
34934
34935
34936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34937   unsigned int jresult ;
34938   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34939   bool result;
34940
34941   arg1 = (Dali::CustomActorImpl *)jarg1;
34942   {
34943     try {
34944       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34945     } catch (std::out_of_range& e) {
34946       {
34947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34948       };
34949     } catch (std::exception& e) {
34950       {
34951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34952       };
34953     } catch (...) {
34954       {
34955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34956       };
34957     }
34958   }
34959   jresult = result;
34960   return jresult;
34961 }
34962
34963
34964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34965   unsigned int jresult ;
34966   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34967   bool result;
34968
34969   arg1 = (Dali::CustomActorImpl *)jarg1;
34970   {
34971     try {
34972       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34973     } catch (std::out_of_range& e) {
34974       {
34975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34976       };
34977     } catch (std::exception& e) {
34978       {
34979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34980       };
34981     } catch (...) {
34982       {
34983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34984       };
34985     }
34986   }
34987   jresult = result;
34988   return jresult;
34989 }
34990
34991
34992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34993   unsigned int jresult ;
34994   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34995   bool result;
34996
34997   arg1 = (Dali::CustomActorImpl *)jarg1;
34998   {
34999     try {
35000       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
35001     } catch (std::out_of_range& e) {
35002       {
35003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35004       };
35005     } catch (std::exception& e) {
35006       {
35007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35008       };
35009     } catch (...) {
35010       {
35011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35012       };
35013     }
35014   }
35015   jresult = result;
35016   return jresult;
35017 }
35018
35019
35020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35021   void * jresult ;
35022   Dali::CustomActor *result = 0 ;
35023
35024   {
35025     try {
35026       result = (Dali::CustomActor *)new Dali::CustomActor();
35027     } catch (std::out_of_range& e) {
35028       {
35029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (std::exception& e) {
35032       {
35033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041   jresult = (void *)result;
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35047   void * jresult ;
35048   Dali::BaseHandle arg1 ;
35049   Dali::BaseHandle *argp1 ;
35050   Dali::CustomActor result;
35051
35052   argp1 = (Dali::BaseHandle *)jarg1;
35053   if (!argp1) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35055     return 0;
35056   }
35057   arg1 = *argp1;
35058   {
35059     try {
35060       result = Dali::CustomActor::DownCast(arg1);
35061     } catch (std::out_of_range& e) {
35062       {
35063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35064       };
35065     } catch (std::exception& e) {
35066       {
35067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35068       };
35069     } catch (...) {
35070       {
35071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35072       };
35073     }
35074   }
35075   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35081   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35082
35083   arg1 = (Dali::CustomActor *)jarg1;
35084   {
35085     try {
35086       delete arg1;
35087     } catch (std::out_of_range& e) {
35088       {
35089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35090       };
35091     } catch (std::exception& e) {
35092       {
35093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (...) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35098       };
35099     }
35100   }
35101 }
35102
35103
35104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35105   void * jresult ;
35106   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35107   Dali::CustomActorImpl *result = 0 ;
35108
35109   arg1 = (Dali::CustomActor *)jarg1;
35110   {
35111     try {
35112       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35113     } catch (std::out_of_range& e) {
35114       {
35115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (std::exception& e) {
35118       {
35119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35120       };
35121     } catch (...) {
35122       {
35123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35124       };
35125     }
35126   }
35127   jresult = (void *)result;
35128   return jresult;
35129 }
35130
35131
35132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35133   void * jresult ;
35134   Dali::CustomActorImpl *arg1 = 0 ;
35135   Dali::CustomActor *result = 0 ;
35136
35137   arg1 = (Dali::CustomActorImpl *)jarg1;
35138   if (!arg1) {
35139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35140     return 0;
35141   }
35142   {
35143     try {
35144       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35145     } catch (std::out_of_range& e) {
35146       {
35147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35148       };
35149     } catch (std::exception& e) {
35150       {
35151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35156       };
35157     }
35158   }
35159   jresult = (void *)result;
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35165   void * jresult ;
35166   Dali::CustomActor *arg1 = 0 ;
35167   Dali::CustomActor *result = 0 ;
35168
35169   arg1 = (Dali::CustomActor *)jarg1;
35170   if (!arg1) {
35171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35172     return 0;
35173   }
35174   {
35175     try {
35176       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35177     } catch (std::out_of_range& e) {
35178       {
35179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35180       };
35181     } catch (std::exception& e) {
35182       {
35183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35184       };
35185     } catch (...) {
35186       {
35187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35188       };
35189     }
35190   }
35191   jresult = (void *)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35197   void * jresult ;
35198   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35199   Dali::CustomActor *arg2 = 0 ;
35200   Dali::CustomActor *result = 0 ;
35201
35202   arg1 = (Dali::CustomActor *)jarg1;
35203   arg2 = (Dali::CustomActor *)jarg2;
35204   if (!arg2) {
35205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35206     return 0;
35207   }
35208   {
35209     try {
35210       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35211     } catch (std::out_of_range& e) {
35212       {
35213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35214       };
35215     } catch (std::exception& e) {
35216       {
35217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35222       };
35223     }
35224   }
35225   jresult = (void *)result;
35226   return jresult;
35227 }
35228
35229
35230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35231   int jresult ;
35232   int result;
35233
35234   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35235   jresult = (int)result;
35236   return jresult;
35237 }
35238
35239
35240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35241   int jresult ;
35242   int result;
35243
35244   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35245   jresult = (int)result;
35246   return jresult;
35247 }
35248
35249
35250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35251   int jresult ;
35252   int result;
35253
35254   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35255   jresult = (int)result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35261   int jresult ;
35262   int result;
35263
35264   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35265   jresult = (int)result;
35266   return jresult;
35267 }
35268
35269
35270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35271   int jresult ;
35272   int result;
35273
35274   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35275   jresult = (int)result;
35276   return jresult;
35277 }
35278
35279
35280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35281   int jresult ;
35282   int result;
35283
35284   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35285   jresult = (int)result;
35286   return jresult;
35287 }
35288
35289
35290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35291   int jresult ;
35292   int result;
35293
35294   result = (int)Dali::PanGestureDetector::Property::PANNING;
35295   jresult = (int)result;
35296   return jresult;
35297 }
35298
35299
35300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35301   void * jresult ;
35302   Dali::PanGestureDetector::Property *result = 0 ;
35303
35304   {
35305     try {
35306       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35307     } catch (std::out_of_range& e) {
35308       {
35309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (std::exception& e) {
35312       {
35313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35318       };
35319     }
35320   }
35321   jresult = (void *)result;
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35327   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35328
35329   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35330   {
35331     try {
35332       delete arg1;
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (...) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35344       };
35345     }
35346   }
35347 }
35348
35349
35350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35351   void * jresult ;
35352   Dali::Radian *result = 0 ;
35353
35354   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35355   jresult = (void *)result;
35356   return jresult;
35357 }
35358
35359
35360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35361   void * jresult ;
35362   Dali::Radian *result = 0 ;
35363
35364   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35365   jresult = (void *)result;
35366   return jresult;
35367 }
35368
35369
35370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35371   void * jresult ;
35372   Dali::Radian *result = 0 ;
35373
35374   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35375   jresult = (void *)result;
35376   return jresult;
35377 }
35378
35379
35380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35381   void * jresult ;
35382   Dali::Radian *result = 0 ;
35383
35384   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35385   jresult = (void *)result;
35386   return jresult;
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35391   void * jresult ;
35392   Dali::Radian *result = 0 ;
35393
35394   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35395   jresult = (void *)result;
35396   return jresult;
35397 }
35398
35399
35400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35401   void * jresult ;
35402   Dali::Radian *result = 0 ;
35403
35404   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35405   jresult = (void *)result;
35406   return jresult;
35407 }
35408
35409
35410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35411   void * jresult ;
35412   Dali::Radian *result = 0 ;
35413
35414   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35415   jresult = (void *)result;
35416   return jresult;
35417 }
35418
35419
35420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35421   void * jresult ;
35422   Dali::PanGestureDetector *result = 0 ;
35423
35424   {
35425     try {
35426       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35427     } catch (std::out_of_range& e) {
35428       {
35429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35430       };
35431     } catch (std::exception& e) {
35432       {
35433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (...) {
35436       {
35437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35438       };
35439     }
35440   }
35441   jresult = (void *)result;
35442   return jresult;
35443 }
35444
35445
35446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35447   void * jresult ;
35448   Dali::PanGestureDetector result;
35449
35450   {
35451     try {
35452       result = Dali::PanGestureDetector::New();
35453     } catch (std::out_of_range& e) {
35454       {
35455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35456       };
35457     } catch (std::exception& e) {
35458       {
35459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35460       };
35461     } catch (...) {
35462       {
35463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35464       };
35465     }
35466   }
35467   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35468   return jresult;
35469 }
35470
35471
35472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35473   void * jresult ;
35474   Dali::BaseHandle arg1 ;
35475   Dali::BaseHandle *argp1 ;
35476   Dali::PanGestureDetector result;
35477
35478   argp1 = (Dali::BaseHandle *)jarg1;
35479   if (!argp1) {
35480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35481     return 0;
35482   }
35483   arg1 = *argp1;
35484   {
35485     try {
35486       result = Dali::PanGestureDetector::DownCast(arg1);
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35507   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35508
35509   arg1 = (Dali::PanGestureDetector *)jarg1;
35510   {
35511     try {
35512       delete arg1;
35513     } catch (std::out_of_range& e) {
35514       {
35515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35516       };
35517     } catch (std::exception& e) {
35518       {
35519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35520       };
35521     } catch (...) {
35522       {
35523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35524       };
35525     }
35526   }
35527 }
35528
35529
35530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35531   void * jresult ;
35532   Dali::PanGestureDetector *arg1 = 0 ;
35533   Dali::PanGestureDetector *result = 0 ;
35534
35535   arg1 = (Dali::PanGestureDetector *)jarg1;
35536   if (!arg1) {
35537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35538     return 0;
35539   }
35540   {
35541     try {
35542       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35554       };
35555     }
35556   }
35557   jresult = (void *)result;
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35563   void * jresult ;
35564   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35565   Dali::PanGestureDetector *arg2 = 0 ;
35566   Dali::PanGestureDetector *result = 0 ;
35567
35568   arg1 = (Dali::PanGestureDetector *)jarg1;
35569   arg2 = (Dali::PanGestureDetector *)jarg2;
35570   if (!arg2) {
35571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35572     return 0;
35573   }
35574   {
35575     try {
35576       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35577     } catch (std::out_of_range& e) {
35578       {
35579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35580       };
35581     } catch (std::exception& e) {
35582       {
35583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35584       };
35585     } catch (...) {
35586       {
35587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35588       };
35589     }
35590   }
35591   jresult = (void *)result;
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35597   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35598   unsigned int arg2 ;
35599
35600   arg1 = (Dali::PanGestureDetector *)jarg1;
35601   arg2 = (unsigned int)jarg2;
35602   {
35603     try {
35604       (arg1)->SetMinimumTouchesRequired(arg2);
35605     } catch (std::out_of_range& e) {
35606       {
35607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (std::exception& e) {
35610       {
35611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35616       };
35617     }
35618   }
35619 }
35620
35621
35622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35624   unsigned int arg2 ;
35625
35626   arg1 = (Dali::PanGestureDetector *)jarg1;
35627   arg2 = (unsigned int)jarg2;
35628   {
35629     try {
35630       (arg1)->SetMaximumTouchesRequired(arg2);
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35638       };
35639     } catch (...) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35642       };
35643     }
35644   }
35645 }
35646
35647
35648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35649   unsigned int jresult ;
35650   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35651   unsigned int result;
35652
35653   arg1 = (Dali::PanGestureDetector *)jarg1;
35654   {
35655     try {
35656       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (...) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35668       };
35669     }
35670   }
35671   jresult = result;
35672   return jresult;
35673 }
35674
35675
35676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35677   unsigned int jresult ;
35678   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35679   unsigned int result;
35680
35681   arg1 = (Dali::PanGestureDetector *)jarg1;
35682   {
35683     try {
35684       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35685     } catch (std::out_of_range& e) {
35686       {
35687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35688       };
35689     } catch (std::exception& e) {
35690       {
35691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (...) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35696       };
35697     }
35698   }
35699   jresult = result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35705   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35706   Dali::Radian arg2 ;
35707   Dali::Radian arg3 ;
35708   Dali::Radian *argp2 ;
35709   Dali::Radian *argp3 ;
35710
35711   arg1 = (Dali::PanGestureDetector *)jarg1;
35712   argp2 = (Dali::Radian *)jarg2;
35713   if (!argp2) {
35714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35715     return ;
35716   }
35717   arg2 = *argp2;
35718   argp3 = (Dali::Radian *)jarg3;
35719   if (!argp3) {
35720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35721     return ;
35722   }
35723   arg3 = *argp3;
35724   {
35725     try {
35726       (arg1)->AddAngle(arg2,arg3);
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35738       };
35739     }
35740   }
35741 }
35742
35743
35744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35745   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35746   Dali::Radian arg2 ;
35747   Dali::Radian *argp2 ;
35748
35749   arg1 = (Dali::PanGestureDetector *)jarg1;
35750   argp2 = (Dali::Radian *)jarg2;
35751   if (!argp2) {
35752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35753     return ;
35754   }
35755   arg2 = *argp2;
35756   {
35757     try {
35758       (arg1)->AddAngle(arg2);
35759     } catch (std::out_of_range& e) {
35760       {
35761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35762       };
35763     } catch (std::exception& e) {
35764       {
35765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35766       };
35767     } catch (...) {
35768       {
35769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35770       };
35771     }
35772   }
35773 }
35774
35775
35776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35778   Dali::Radian arg2 ;
35779   Dali::Radian arg3 ;
35780   Dali::Radian *argp2 ;
35781   Dali::Radian *argp3 ;
35782
35783   arg1 = (Dali::PanGestureDetector *)jarg1;
35784   argp2 = (Dali::Radian *)jarg2;
35785   if (!argp2) {
35786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35787     return ;
35788   }
35789   arg2 = *argp2;
35790   argp3 = (Dali::Radian *)jarg3;
35791   if (!argp3) {
35792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35793     return ;
35794   }
35795   arg3 = *argp3;
35796   {
35797     try {
35798       (arg1)->AddDirection(arg2,arg3);
35799     } catch (std::out_of_range& e) {
35800       {
35801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (std::exception& e) {
35804       {
35805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35810       };
35811     }
35812   }
35813 }
35814
35815
35816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35817   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35818   Dali::Radian arg2 ;
35819   Dali::Radian *argp2 ;
35820
35821   arg1 = (Dali::PanGestureDetector *)jarg1;
35822   argp2 = (Dali::Radian *)jarg2;
35823   if (!argp2) {
35824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35825     return ;
35826   }
35827   arg2 = *argp2;
35828   {
35829     try {
35830       (arg1)->AddDirection(arg2);
35831     } catch (std::out_of_range& e) {
35832       {
35833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35834       };
35835     } catch (std::exception& e) {
35836       {
35837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35842       };
35843     }
35844   }
35845 }
35846
35847
35848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35849   unsigned long jresult ;
35850   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35851   size_t result;
35852
35853   arg1 = (Dali::PanGestureDetector *)jarg1;
35854   {
35855     try {
35856       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35857     } catch (std::out_of_range& e) {
35858       {
35859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35860       };
35861     } catch (std::exception& e) {
35862       {
35863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35868       };
35869     }
35870   }
35871   jresult = (unsigned long)result;
35872   return jresult;
35873 }
35874
35875
35876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35877   void * jresult ;
35878   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35879   size_t arg2 ;
35880   Dali::PanGestureDetector::AngleThresholdPair result;
35881
35882   arg1 = (Dali::PanGestureDetector *)jarg1;
35883   arg2 = (size_t)jarg2;
35884   {
35885     try {
35886       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35887     } catch (std::out_of_range& e) {
35888       {
35889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35890       };
35891     } catch (std::exception& e) {
35892       {
35893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35898       };
35899     }
35900   }
35901   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35902   return jresult;
35903 }
35904
35905
35906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35907   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35908
35909   arg1 = (Dali::PanGestureDetector *)jarg1;
35910   {
35911     try {
35912       (arg1)->ClearAngles();
35913     } catch (std::out_of_range& e) {
35914       {
35915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35916       };
35917     } catch (std::exception& e) {
35918       {
35919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (...) {
35922       {
35923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35924       };
35925     }
35926   }
35927 }
35928
35929
35930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35931   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35932   Dali::Radian arg2 ;
35933   Dali::Radian *argp2 ;
35934
35935   arg1 = (Dali::PanGestureDetector *)jarg1;
35936   argp2 = (Dali::Radian *)jarg2;
35937   if (!argp2) {
35938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35939     return ;
35940   }
35941   arg2 = *argp2;
35942   {
35943     try {
35944       (arg1)->RemoveAngle(arg2);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (...) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35956       };
35957     }
35958   }
35959 }
35960
35961
35962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35963   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35964   Dali::Radian arg2 ;
35965   Dali::Radian *argp2 ;
35966
35967   arg1 = (Dali::PanGestureDetector *)jarg1;
35968   argp2 = (Dali::Radian *)jarg2;
35969   if (!argp2) {
35970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35971     return ;
35972   }
35973   arg2 = *argp2;
35974   {
35975     try {
35976       (arg1)->RemoveDirection(arg2);
35977     } catch (std::out_of_range& e) {
35978       {
35979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35980       };
35981     } catch (std::exception& e) {
35982       {
35983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35984       };
35985     } catch (...) {
35986       {
35987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35988       };
35989     }
35990   }
35991 }
35992
35993
35994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35995   void * jresult ;
35996   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35997   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35998
35999   arg1 = (Dali::PanGestureDetector *)jarg1;
36000   {
36001     try {
36002       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36003     } catch (std::out_of_range& e) {
36004       {
36005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36006       };
36007     } catch (std::exception& e) {
36008       {
36009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36010       };
36011     } catch (...) {
36012       {
36013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36014       };
36015     }
36016   }
36017   jresult = (void *)result;
36018   return jresult;
36019 }
36020
36021
36022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36023   Dali::PanGesture *arg1 = 0 ;
36024
36025   arg1 = (Dali::PanGesture *)jarg1;
36026   if (!arg1) {
36027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36028     return ;
36029   }
36030   {
36031     try {
36032       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36044       };
36045     }
36046   }
36047 }
36048
36049
36050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36051   void * jresult ;
36052   Dali::PanGesture *result = 0 ;
36053
36054   {
36055     try {
36056       result = (Dali::PanGesture *)new Dali::PanGesture();
36057     } catch (std::out_of_range& e) {
36058       {
36059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (std::exception& e) {
36062       {
36063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071   jresult = (void *)result;
36072   return jresult;
36073 }
36074
36075
36076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36077   void * jresult ;
36078   Dali::Gesture::State arg1 ;
36079   Dali::PanGesture *result = 0 ;
36080
36081   arg1 = (Dali::Gesture::State)jarg1;
36082   {
36083     try {
36084       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36085     } catch (std::out_of_range& e) {
36086       {
36087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36088       };
36089     } catch (std::exception& e) {
36090       {
36091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36096       };
36097     }
36098   }
36099   jresult = (void *)result;
36100   return jresult;
36101 }
36102
36103
36104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36105   void * jresult ;
36106   Dali::PanGesture *arg1 = 0 ;
36107   Dali::PanGesture *result = 0 ;
36108
36109   arg1 = (Dali::PanGesture *)jarg1;
36110   if (!arg1) {
36111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36112     return 0;
36113   }
36114   {
36115     try {
36116       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (...) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36128       };
36129     }
36130   }
36131   jresult = (void *)result;
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36137   void * jresult ;
36138   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36139   Dali::PanGesture *arg2 = 0 ;
36140   Dali::PanGesture *result = 0 ;
36141
36142   arg1 = (Dali::PanGesture *)jarg1;
36143   arg2 = (Dali::PanGesture *)jarg2;
36144   if (!arg2) {
36145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36146     return 0;
36147   }
36148   {
36149     try {
36150       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (...) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36162       };
36163     }
36164   }
36165   jresult = (void *)result;
36166   return jresult;
36167 }
36168
36169
36170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36171   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   {
36175     try {
36176       delete arg1;
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (...) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36188       };
36189     }
36190   }
36191 }
36192
36193
36194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36197
36198   arg1 = (Dali::PanGesture *)jarg1;
36199   arg2 = (Dali::Vector2 *)jarg2;
36200   if (arg1) (arg1)->velocity = *arg2;
36201 }
36202
36203
36204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36205   void * jresult ;
36206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36207   Dali::Vector2 *result = 0 ;
36208
36209   arg1 = (Dali::PanGesture *)jarg1;
36210   result = (Dali::Vector2 *)& ((arg1)->velocity);
36211   jresult = (void *)result;
36212   return jresult;
36213 }
36214
36215
36216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36219
36220   arg1 = (Dali::PanGesture *)jarg1;
36221   arg2 = (Dali::Vector2 *)jarg2;
36222   if (arg1) (arg1)->displacement = *arg2;
36223 }
36224
36225
36226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36227   void * jresult ;
36228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36229   Dali::Vector2 *result = 0 ;
36230
36231   arg1 = (Dali::PanGesture *)jarg1;
36232   result = (Dali::Vector2 *)& ((arg1)->displacement);
36233   jresult = (void *)result;
36234   return jresult;
36235 }
36236
36237
36238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36240   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36241
36242   arg1 = (Dali::PanGesture *)jarg1;
36243   arg2 = (Dali::Vector2 *)jarg2;
36244   if (arg1) (arg1)->position = *arg2;
36245 }
36246
36247
36248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36249   void * jresult ;
36250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36251   Dali::Vector2 *result = 0 ;
36252
36253   arg1 = (Dali::PanGesture *)jarg1;
36254   result = (Dali::Vector2 *)& ((arg1)->position);
36255   jresult = (void *)result;
36256   return jresult;
36257 }
36258
36259
36260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36262   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36263
36264   arg1 = (Dali::PanGesture *)jarg1;
36265   arg2 = (Dali::Vector2 *)jarg2;
36266   if (arg1) (arg1)->screenVelocity = *arg2;
36267 }
36268
36269
36270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36271   void * jresult ;
36272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36273   Dali::Vector2 *result = 0 ;
36274
36275   arg1 = (Dali::PanGesture *)jarg1;
36276   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36277   jresult = (void *)result;
36278   return jresult;
36279 }
36280
36281
36282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36284   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36285
36286   arg1 = (Dali::PanGesture *)jarg1;
36287   arg2 = (Dali::Vector2 *)jarg2;
36288   if (arg1) (arg1)->screenDisplacement = *arg2;
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36293   void * jresult ;
36294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36295   Dali::Vector2 *result = 0 ;
36296
36297   arg1 = (Dali::PanGesture *)jarg1;
36298   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36299   jresult = (void *)result;
36300   return jresult;
36301 }
36302
36303
36304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   arg2 = (Dali::Vector2 *)jarg2;
36310   if (arg1) (arg1)->screenPosition = *arg2;
36311 }
36312
36313
36314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36315   void * jresult ;
36316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36317   Dali::Vector2 *result = 0 ;
36318
36319   arg1 = (Dali::PanGesture *)jarg1;
36320   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36321   jresult = (void *)result;
36322   return jresult;
36323 }
36324
36325
36326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36327   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36328   unsigned int arg2 ;
36329
36330   arg1 = (Dali::PanGesture *)jarg1;
36331   arg2 = (unsigned int)jarg2;
36332   if (arg1) (arg1)->numberOfTouches = arg2;
36333 }
36334
36335
36336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36337   unsigned int jresult ;
36338   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36339   unsigned int result;
36340
36341   arg1 = (Dali::PanGesture *)jarg1;
36342   result = (unsigned int) ((arg1)->numberOfTouches);
36343   jresult = result;
36344   return jresult;
36345 }
36346
36347
36348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36349   float jresult ;
36350   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36351   float result;
36352
36353   arg1 = (Dali::PanGesture *)jarg1;
36354   {
36355     try {
36356       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36377   float jresult ;
36378   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36379   float result;
36380
36381   arg1 = (Dali::PanGesture *)jarg1;
36382   {
36383     try {
36384       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (...) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36396       };
36397     }
36398   }
36399   jresult = result;
36400   return jresult;
36401 }
36402
36403
36404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36405   float jresult ;
36406   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36407   float result;
36408
36409   arg1 = (Dali::PanGesture *)jarg1;
36410   {
36411     try {
36412       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36413     } catch (std::out_of_range& e) {
36414       {
36415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (std::exception& e) {
36418       {
36419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36420       };
36421     } catch (...) {
36422       {
36423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36424       };
36425     }
36426   }
36427   jresult = result;
36428   return jresult;
36429 }
36430
36431
36432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36433   float jresult ;
36434   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36435   float result;
36436
36437   arg1 = (Dali::PanGesture *)jarg1;
36438   {
36439     try {
36440       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36441     } catch (std::out_of_range& e) {
36442       {
36443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36444       };
36445     } catch (std::exception& e) {
36446       {
36447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36448       };
36449     } catch (...) {
36450       {
36451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36452       };
36453     }
36454   }
36455   jresult = result;
36456   return jresult;
36457 }
36458
36459
36460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36461   void * jresult ;
36462   Dali::PinchGestureDetector *result = 0 ;
36463
36464   {
36465     try {
36466       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36467     } catch (std::out_of_range& e) {
36468       {
36469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (std::exception& e) {
36472       {
36473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36474       };
36475     } catch (...) {
36476       {
36477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36478       };
36479     }
36480   }
36481   jresult = (void *)result;
36482   return jresult;
36483 }
36484
36485
36486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36487   void * jresult ;
36488   Dali::PinchGestureDetector result;
36489
36490   {
36491     try {
36492       result = Dali::PinchGestureDetector::New();
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (...) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36504       };
36505     }
36506   }
36507   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36513   void * jresult ;
36514   Dali::BaseHandle arg1 ;
36515   Dali::BaseHandle *argp1 ;
36516   Dali::PinchGestureDetector result;
36517
36518   argp1 = (Dali::BaseHandle *)jarg1;
36519   if (!argp1) {
36520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36521     return 0;
36522   }
36523   arg1 = *argp1;
36524   {
36525     try {
36526       result = Dali::PinchGestureDetector::DownCast(arg1);
36527     } catch (std::out_of_range& e) {
36528       {
36529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (std::exception& e) {
36532       {
36533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36534       };
36535     } catch (...) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36538       };
36539     }
36540   }
36541   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36542   return jresult;
36543 }
36544
36545
36546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36547   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36548
36549   arg1 = (Dali::PinchGestureDetector *)jarg1;
36550   {
36551     try {
36552       delete arg1;
36553     } catch (std::out_of_range& e) {
36554       {
36555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36556       };
36557     } catch (std::exception& e) {
36558       {
36559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (...) {
36562       {
36563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36564       };
36565     }
36566   }
36567 }
36568
36569
36570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36571   void * jresult ;
36572   Dali::PinchGestureDetector *arg1 = 0 ;
36573   Dali::PinchGestureDetector *result = 0 ;
36574
36575   arg1 = (Dali::PinchGestureDetector *)jarg1;
36576   if (!arg1) {
36577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36578     return 0;
36579   }
36580   {
36581     try {
36582       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36583     } catch (std::out_of_range& e) {
36584       {
36585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36586       };
36587     } catch (std::exception& e) {
36588       {
36589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36590       };
36591     } catch (...) {
36592       {
36593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36594       };
36595     }
36596   }
36597   jresult = (void *)result;
36598   return jresult;
36599 }
36600
36601
36602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36603   void * jresult ;
36604   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36605   Dali::PinchGestureDetector *arg2 = 0 ;
36606   Dali::PinchGestureDetector *result = 0 ;
36607
36608   arg1 = (Dali::PinchGestureDetector *)jarg1;
36609   arg2 = (Dali::PinchGestureDetector *)jarg2;
36610   if (!arg2) {
36611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36612     return 0;
36613   }
36614   {
36615     try {
36616       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36617     } catch (std::out_of_range& e) {
36618       {
36619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36620       };
36621     } catch (std::exception& e) {
36622       {
36623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36624       };
36625     } catch (...) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36628       };
36629     }
36630   }
36631   jresult = (void *)result;
36632   return jresult;
36633 }
36634
36635
36636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36637   void * jresult ;
36638   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36639   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36640
36641   arg1 = (Dali::PinchGestureDetector *)jarg1;
36642   {
36643     try {
36644       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36645     } catch (std::out_of_range& e) {
36646       {
36647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36648       };
36649     } catch (std::exception& e) {
36650       {
36651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36652       };
36653     } catch (...) {
36654       {
36655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36656       };
36657     }
36658   }
36659   jresult = (void *)result;
36660   return jresult;
36661 }
36662
36663
36664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36665   void * jresult ;
36666   Dali::Gesture::State arg1 ;
36667   Dali::PinchGesture *result = 0 ;
36668
36669   arg1 = (Dali::Gesture::State)jarg1;
36670   {
36671     try {
36672       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36673     } catch (std::out_of_range& e) {
36674       {
36675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36676       };
36677     } catch (std::exception& e) {
36678       {
36679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36684       };
36685     }
36686   }
36687   jresult = (void *)result;
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36693   void * jresult ;
36694   Dali::PinchGesture *arg1 = 0 ;
36695   Dali::PinchGesture *result = 0 ;
36696
36697   arg1 = (Dali::PinchGesture *)jarg1;
36698   if (!arg1) {
36699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36700     return 0;
36701   }
36702   {
36703     try {
36704       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36705     } catch (std::out_of_range& e) {
36706       {
36707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (std::exception& e) {
36710       {
36711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719   jresult = (void *)result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36725   void * jresult ;
36726   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36727   Dali::PinchGesture *arg2 = 0 ;
36728   Dali::PinchGesture *result = 0 ;
36729
36730   arg1 = (Dali::PinchGesture *)jarg1;
36731   arg2 = (Dali::PinchGesture *)jarg2;
36732   if (!arg2) {
36733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36734     return 0;
36735   }
36736   {
36737     try {
36738       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36739     } catch (std::out_of_range& e) {
36740       {
36741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36742       };
36743     } catch (std::exception& e) {
36744       {
36745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36746       };
36747     } catch (...) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36750       };
36751     }
36752   }
36753   jresult = (void *)result;
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   {
36763     try {
36764       delete arg1;
36765     } catch (std::out_of_range& e) {
36766       {
36767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36768       };
36769     } catch (std::exception& e) {
36770       {
36771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36772       };
36773     } catch (...) {
36774       {
36775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36776       };
36777     }
36778   }
36779 }
36780
36781
36782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36783   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36784   float arg2 ;
36785
36786   arg1 = (Dali::PinchGesture *)jarg1;
36787   arg2 = (float)jarg2;
36788   if (arg1) (arg1)->scale = arg2;
36789 }
36790
36791
36792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36793   float jresult ;
36794   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36795   float result;
36796
36797   arg1 = (Dali::PinchGesture *)jarg1;
36798   result = (float) ((arg1)->scale);
36799   jresult = result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36805   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36806   float arg2 ;
36807
36808   arg1 = (Dali::PinchGesture *)jarg1;
36809   arg2 = (float)jarg2;
36810   if (arg1) (arg1)->speed = arg2;
36811 }
36812
36813
36814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36815   float jresult ;
36816   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36817   float result;
36818
36819   arg1 = (Dali::PinchGesture *)jarg1;
36820   result = (float) ((arg1)->speed);
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36827   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36828   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36829
36830   arg1 = (Dali::PinchGesture *)jarg1;
36831   arg2 = (Dali::Vector2 *)jarg2;
36832   if (arg1) (arg1)->screenCenterPoint = *arg2;
36833 }
36834
36835
36836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36837   void * jresult ;
36838   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36839   Dali::Vector2 *result = 0 ;
36840
36841   arg1 = (Dali::PinchGesture *)jarg1;
36842   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36843   jresult = (void *)result;
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36849   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36850   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36851
36852   arg1 = (Dali::PinchGesture *)jarg1;
36853   arg2 = (Dali::Vector2 *)jarg2;
36854   if (arg1) (arg1)->localCenterPoint = *arg2;
36855 }
36856
36857
36858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36859   void * jresult ;
36860   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36861   Dali::Vector2 *result = 0 ;
36862
36863   arg1 = (Dali::PinchGesture *)jarg1;
36864   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36865   jresult = (void *)result;
36866   return jresult;
36867 }
36868
36869
36870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36871   void * jresult ;
36872   Dali::TapGestureDetector *result = 0 ;
36873
36874   {
36875     try {
36876       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (...) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36888       };
36889     }
36890   }
36891   jresult = (void *)result;
36892   return jresult;
36893 }
36894
36895
36896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36897   void * jresult ;
36898   Dali::TapGestureDetector result;
36899
36900   {
36901     try {
36902       result = Dali::TapGestureDetector::New();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (...) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36914       };
36915     }
36916   }
36917   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36918   return jresult;
36919 }
36920
36921
36922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36923   void * jresult ;
36924   unsigned int arg1 ;
36925   Dali::TapGestureDetector result;
36926
36927   arg1 = (unsigned int)jarg1;
36928   {
36929     try {
36930       result = Dali::TapGestureDetector::New(arg1);
36931     } catch (std::out_of_range& e) {
36932       {
36933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36934       };
36935     } catch (std::exception& e) {
36936       {
36937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36938       };
36939     } catch (...) {
36940       {
36941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36942       };
36943     }
36944   }
36945   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36946   return jresult;
36947 }
36948
36949
36950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36951   void * jresult ;
36952   Dali::BaseHandle arg1 ;
36953   Dali::BaseHandle *argp1 ;
36954   Dali::TapGestureDetector result;
36955
36956   argp1 = (Dali::BaseHandle *)jarg1;
36957   if (!argp1) {
36958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36959     return 0;
36960   }
36961   arg1 = *argp1;
36962   {
36963     try {
36964       result = Dali::TapGestureDetector::DownCast(arg1);
36965     } catch (std::out_of_range& e) {
36966       {
36967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36968       };
36969     } catch (std::exception& e) {
36970       {
36971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (...) {
36974       {
36975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36976       };
36977     }
36978   }
36979   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36985   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36986
36987   arg1 = (Dali::TapGestureDetector *)jarg1;
36988   {
36989     try {
36990       delete arg1;
36991     } catch (std::out_of_range& e) {
36992       {
36993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36994       };
36995     } catch (std::exception& e) {
36996       {
36997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36998       };
36999     } catch (...) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37002       };
37003     }
37004   }
37005 }
37006
37007
37008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37009   void * jresult ;
37010   Dali::TapGestureDetector *arg1 = 0 ;
37011   Dali::TapGestureDetector *result = 0 ;
37012
37013   arg1 = (Dali::TapGestureDetector *)jarg1;
37014   if (!arg1) {
37015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37016     return 0;
37017   }
37018   {
37019     try {
37020       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37021     } catch (std::out_of_range& e) {
37022       {
37023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37024       };
37025     } catch (std::exception& e) {
37026       {
37027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37028       };
37029     } catch (...) {
37030       {
37031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37032       };
37033     }
37034   }
37035   jresult = (void *)result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37041   void * jresult ;
37042   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37043   Dali::TapGestureDetector *arg2 = 0 ;
37044   Dali::TapGestureDetector *result = 0 ;
37045
37046   arg1 = (Dali::TapGestureDetector *)jarg1;
37047   arg2 = (Dali::TapGestureDetector *)jarg2;
37048   if (!arg2) {
37049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37050     return 0;
37051   }
37052   {
37053     try {
37054       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37055     } catch (std::out_of_range& e) {
37056       {
37057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (std::exception& e) {
37060       {
37061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37066       };
37067     }
37068   }
37069   jresult = (void *)result;
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37075   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37076   unsigned int arg2 ;
37077
37078   arg1 = (Dali::TapGestureDetector *)jarg1;
37079   arg2 = (unsigned int)jarg2;
37080   {
37081     try {
37082       (arg1)->SetMinimumTapsRequired(arg2);
37083     } catch (std::out_of_range& e) {
37084       {
37085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37086       };
37087     } catch (std::exception& e) {
37088       {
37089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37090       };
37091     } catch (...) {
37092       {
37093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37094       };
37095     }
37096   }
37097 }
37098
37099
37100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37101   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37102   unsigned int arg2 ;
37103
37104   arg1 = (Dali::TapGestureDetector *)jarg1;
37105   arg2 = (unsigned int)jarg2;
37106   {
37107     try {
37108       (arg1)->SetMaximumTapsRequired(arg2);
37109     } catch (std::out_of_range& e) {
37110       {
37111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37112       };
37113     } catch (std::exception& e) {
37114       {
37115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37120       };
37121     }
37122   }
37123 }
37124
37125
37126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37127   unsigned int jresult ;
37128   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37129   unsigned int result;
37130
37131   arg1 = (Dali::TapGestureDetector *)jarg1;
37132   {
37133     try {
37134       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37135     } catch (std::out_of_range& e) {
37136       {
37137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (std::exception& e) {
37140       {
37141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149   jresult = result;
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37155   unsigned int jresult ;
37156   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37157   unsigned int result;
37158
37159   arg1 = (Dali::TapGestureDetector *)jarg1;
37160   {
37161     try {
37162       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37163     } catch (std::out_of_range& e) {
37164       {
37165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37166       };
37167     } catch (std::exception& e) {
37168       {
37169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37170       };
37171     } catch (...) {
37172       {
37173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37174       };
37175     }
37176   }
37177   jresult = result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37183   void * jresult ;
37184   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37185   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37186
37187   arg1 = (Dali::TapGestureDetector *)jarg1;
37188   {
37189     try {
37190       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37191     } catch (std::out_of_range& e) {
37192       {
37193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (std::exception& e) {
37196       {
37197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205   jresult = (void *)result;
37206   return jresult;
37207 }
37208
37209
37210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37211   void * jresult ;
37212   Dali::TapGesture *result = 0 ;
37213
37214   {
37215     try {
37216       result = (Dali::TapGesture *)new Dali::TapGesture();
37217     } catch (std::out_of_range& e) {
37218       {
37219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37220       };
37221     } catch (std::exception& e) {
37222       {
37223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37224       };
37225     } catch (...) {
37226       {
37227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37228       };
37229     }
37230   }
37231   jresult = (void *)result;
37232   return jresult;
37233 }
37234
37235
37236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37237   void * jresult ;
37238   Dali::TapGesture *arg1 = 0 ;
37239   Dali::TapGesture *result = 0 ;
37240
37241   arg1 = (Dali::TapGesture *)jarg1;
37242   if (!arg1) {
37243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37244     return 0;
37245   }
37246   {
37247     try {
37248       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37249     } catch (std::out_of_range& e) {
37250       {
37251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37252       };
37253     } catch (std::exception& e) {
37254       {
37255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (...) {
37258       {
37259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37260       };
37261     }
37262   }
37263   jresult = (void *)result;
37264   return jresult;
37265 }
37266
37267
37268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37269   void * jresult ;
37270   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37271   Dali::TapGesture *arg2 = 0 ;
37272   Dali::TapGesture *result = 0 ;
37273
37274   arg1 = (Dali::TapGesture *)jarg1;
37275   arg2 = (Dali::TapGesture *)jarg2;
37276   if (!arg2) {
37277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37278     return 0;
37279   }
37280   {
37281     try {
37282       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37290       };
37291     } catch (...) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37294       };
37295     }
37296   }
37297   jresult = (void *)result;
37298   return jresult;
37299 }
37300
37301
37302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37303   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   {
37307     try {
37308       delete arg1;
37309     } catch (std::out_of_range& e) {
37310       {
37311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37312       };
37313     } catch (std::exception& e) {
37314       {
37315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37316       };
37317     } catch (...) {
37318       {
37319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37320       };
37321     }
37322   }
37323 }
37324
37325
37326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37327   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37328   unsigned int arg2 ;
37329
37330   arg1 = (Dali::TapGesture *)jarg1;
37331   arg2 = (unsigned int)jarg2;
37332   if (arg1) (arg1)->numberOfTaps = arg2;
37333 }
37334
37335
37336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37337   unsigned int jresult ;
37338   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37339   unsigned int result;
37340
37341   arg1 = (Dali::TapGesture *)jarg1;
37342   result = (unsigned int) ((arg1)->numberOfTaps);
37343   jresult = result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37349   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37350   unsigned int arg2 ;
37351
37352   arg1 = (Dali::TapGesture *)jarg1;
37353   arg2 = (unsigned int)jarg2;
37354   if (arg1) (arg1)->numberOfTouches = arg2;
37355 }
37356
37357
37358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37359   unsigned int jresult ;
37360   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37361   unsigned int result;
37362
37363   arg1 = (Dali::TapGesture *)jarg1;
37364   result = (unsigned int) ((arg1)->numberOfTouches);
37365   jresult = result;
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37371   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37373
37374   arg1 = (Dali::TapGesture *)jarg1;
37375   arg2 = (Dali::Vector2 *)jarg2;
37376   if (arg1) (arg1)->screenPoint = *arg2;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37381   void * jresult ;
37382   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37383   Dali::Vector2 *result = 0 ;
37384
37385   arg1 = (Dali::TapGesture *)jarg1;
37386   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37393   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37394   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37395
37396   arg1 = (Dali::TapGesture *)jarg1;
37397   arg2 = (Dali::Vector2 *)jarg2;
37398   if (arg1) (arg1)->localPoint = *arg2;
37399 }
37400
37401
37402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37403   void * jresult ;
37404   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37405   Dali::Vector2 *result = 0 ;
37406
37407   arg1 = (Dali::TapGesture *)jarg1;
37408   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37409   jresult = (void *)result;
37410   return jresult;
37411 }
37412
37413
37414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37415   void * jresult ;
37416   Dali::AlphaFunction *result = 0 ;
37417
37418   {
37419     try {
37420       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37421     } catch (std::out_of_range& e) {
37422       {
37423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37424       };
37425     } catch (std::exception& e) {
37426       {
37427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37428       };
37429     } catch (...) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37432       };
37433     }
37434   }
37435   jresult = (void *)result;
37436   return jresult;
37437 }
37438
37439
37440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37441   void * jresult ;
37442   Dali::AlphaFunction::BuiltinFunction arg1 ;
37443   Dali::AlphaFunction *result = 0 ;
37444
37445   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37446   {
37447     try {
37448       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37449     } catch (std::out_of_range& e) {
37450       {
37451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37452       };
37453     } catch (std::exception& e) {
37454       {
37455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37456       };
37457     } catch (...) {
37458       {
37459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37460       };
37461     }
37462   }
37463   jresult = (void *)result;
37464   return jresult;
37465 }
37466
37467
37468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37469   void * jresult ;
37470   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37471   Dali::AlphaFunction *result = 0 ;
37472
37473   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37474   {
37475     try {
37476       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37484       };
37485     } catch (...) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37488       };
37489     }
37490   }
37491   jresult = (void *)result;
37492   return jresult;
37493 }
37494
37495
37496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37497   void * jresult ;
37498   Dali::Vector2 *arg1 = 0 ;
37499   Dali::Vector2 *arg2 = 0 ;
37500   Dali::AlphaFunction *result = 0 ;
37501
37502   arg1 = (Dali::Vector2 *)jarg1;
37503   if (!arg1) {
37504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37505     return 0;
37506   }
37507   arg2 = (Dali::Vector2 *)jarg2;
37508   if (!arg2) {
37509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37510     return 0;
37511   }
37512   {
37513     try {
37514       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37515     } catch (std::out_of_range& e) {
37516       {
37517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37518       };
37519     } catch (std::exception& e) {
37520       {
37521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37526       };
37527     }
37528   }
37529   jresult = (void *)result;
37530   return jresult;
37531 }
37532
37533
37534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37535   void * jresult ;
37536   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37537   Dali::Vector4 result;
37538
37539   arg1 = (Dali::AlphaFunction *)jarg1;
37540   {
37541     try {
37542       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37543     } catch (std::out_of_range& e) {
37544       {
37545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37546       };
37547     } catch (std::exception& e) {
37548       {
37549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37550       };
37551     } catch (...) {
37552       {
37553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37554       };
37555     }
37556   }
37557   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37558   return jresult;
37559 }
37560
37561
37562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37563   void * jresult ;
37564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37565   Dali::AlphaFunctionPrototype result;
37566
37567   arg1 = (Dali::AlphaFunction *)jarg1;
37568   {
37569     try {
37570       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37571     } catch (std::out_of_range& e) {
37572       {
37573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37574       };
37575     } catch (std::exception& e) {
37576       {
37577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37578       };
37579     } catch (...) {
37580       {
37581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37582       };
37583     }
37584   }
37585   jresult = (void *)result;
37586   return jresult;
37587 }
37588
37589
37590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37591   int jresult ;
37592   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37593   Dali::AlphaFunction::BuiltinFunction result;
37594
37595   arg1 = (Dali::AlphaFunction *)jarg1;
37596   {
37597     try {
37598       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37606       };
37607     } catch (...) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37610       };
37611     }
37612   }
37613   jresult = (int)result;
37614   return jresult;
37615 }
37616
37617
37618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37619   int jresult ;
37620   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37621   Dali::AlphaFunction::Mode result;
37622
37623   arg1 = (Dali::AlphaFunction *)jarg1;
37624   {
37625     try {
37626       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37627     } catch (std::out_of_range& e) {
37628       {
37629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37630       };
37631     } catch (std::exception& e) {
37632       {
37633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37638       };
37639     }
37640   }
37641   jresult = (int)result;
37642   return jresult;
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37647   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37648
37649   arg1 = (Dali::AlphaFunction *)jarg1;
37650   {
37651     try {
37652       delete arg1;
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (...) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37664       };
37665     }
37666   }
37667 }
37668
37669
37670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37671   void * jresult ;
37672   Dali::KeyFrames result;
37673
37674   {
37675     try {
37676       result = Dali::KeyFrames::New();
37677     } catch (std::out_of_range& e) {
37678       {
37679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37680       };
37681     } catch (std::exception& e) {
37682       {
37683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37684       };
37685     } catch (...) {
37686       {
37687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37688       };
37689     }
37690   }
37691   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37692   return jresult;
37693 }
37694
37695
37696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37697   void * jresult ;
37698   Dali::BaseHandle arg1 ;
37699   Dali::BaseHandle *argp1 ;
37700   Dali::KeyFrames result;
37701
37702   argp1 = (Dali::BaseHandle *)jarg1;
37703   if (!argp1) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37705     return 0;
37706   }
37707   arg1 = *argp1;
37708   {
37709     try {
37710       result = Dali::KeyFrames::DownCast(arg1);
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (...) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37722       };
37723     }
37724   }
37725   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37726   return jresult;
37727 }
37728
37729
37730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37731   void * jresult ;
37732   Dali::KeyFrames *result = 0 ;
37733
37734   {
37735     try {
37736       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37737     } catch (std::out_of_range& e) {
37738       {
37739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37740       };
37741     } catch (std::exception& e) {
37742       {
37743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37748       };
37749     }
37750   }
37751   jresult = (void *)result;
37752   return jresult;
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37757   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37758
37759   arg1 = (Dali::KeyFrames *)jarg1;
37760   {
37761     try {
37762       delete arg1;
37763     } catch (std::out_of_range& e) {
37764       {
37765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37766       };
37767     } catch (std::exception& e) {
37768       {
37769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37770       };
37771     } catch (...) {
37772       {
37773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37774       };
37775     }
37776   }
37777 }
37778
37779
37780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37781   void * jresult ;
37782   Dali::KeyFrames *arg1 = 0 ;
37783   Dali::KeyFrames *result = 0 ;
37784
37785   arg1 = (Dali::KeyFrames *)jarg1;
37786   if (!arg1) {
37787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37788     return 0;
37789   }
37790   {
37791     try {
37792       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37804       };
37805     }
37806   }
37807   jresult = (void *)result;
37808   return jresult;
37809 }
37810
37811
37812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37813   void * jresult ;
37814   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37815   Dali::KeyFrames *arg2 = 0 ;
37816   Dali::KeyFrames *result = 0 ;
37817
37818   arg1 = (Dali::KeyFrames *)jarg1;
37819   arg2 = (Dali::KeyFrames *)jarg2;
37820   if (!arg2) {
37821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37822     return 0;
37823   }
37824   {
37825     try {
37826       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37827     } catch (std::out_of_range& e) {
37828       {
37829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37830       };
37831     } catch (std::exception& e) {
37832       {
37833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37838       };
37839     }
37840   }
37841   jresult = (void *)result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37847   int jresult ;
37848   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37849   Dali::Property::Type result;
37850
37851   arg1 = (Dali::KeyFrames *)jarg1;
37852   {
37853     try {
37854       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37855     } catch (std::out_of_range& e) {
37856       {
37857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37858       };
37859     } catch (std::exception& e) {
37860       {
37861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37862       };
37863     } catch (...) {
37864       {
37865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37866       };
37867     }
37868   }
37869   jresult = (int)result;
37870   return jresult;
37871 }
37872
37873
37874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37875   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37876   float arg2 ;
37877   Dali::Property::Value arg3 ;
37878   Dali::Property::Value *argp3 ;
37879
37880   arg1 = (Dali::KeyFrames *)jarg1;
37881   arg2 = (float)jarg2;
37882   argp3 = (Dali::Property::Value *)jarg3;
37883   if (!argp3) {
37884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37885     return ;
37886   }
37887   arg3 = *argp3;
37888   {
37889     try {
37890       (arg1)->Add(arg2,arg3);
37891     } catch (std::out_of_range& e) {
37892       {
37893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (std::exception& e) {
37896       {
37897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905 }
37906
37907
37908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37909   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37910   float arg2 ;
37911   Dali::Property::Value arg3 ;
37912   Dali::AlphaFunction arg4 ;
37913   Dali::Property::Value *argp3 ;
37914   Dali::AlphaFunction *argp4 ;
37915
37916   arg1 = (Dali::KeyFrames *)jarg1;
37917   arg2 = (float)jarg2;
37918   argp3 = (Dali::Property::Value *)jarg3;
37919   if (!argp3) {
37920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37921     return ;
37922   }
37923   arg3 = *argp3;
37924   argp4 = (Dali::AlphaFunction *)jarg4;
37925   if (!argp4) {
37926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37927     return ;
37928   }
37929   arg4 = *argp4;
37930   {
37931     try {
37932       (arg1)->Add(arg2,arg3,arg4);
37933     } catch (std::out_of_range& e) {
37934       {
37935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37936       };
37937     } catch (std::exception& e) {
37938       {
37939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37944       };
37945     }
37946   }
37947 }
37948
37949
37950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37951   int jresult ;
37952   int result;
37953
37954   result = (int)Dali::Path::Property::POINTS;
37955   jresult = (int)result;
37956   return jresult;
37957 }
37958
37959
37960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37961   int jresult ;
37962   int result;
37963
37964   result = (int)Dali::Path::Property::CONTROL_POINTS;
37965   jresult = (int)result;
37966   return jresult;
37967 }
37968
37969
37970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37971   void * jresult ;
37972   Dali::Path::Property *result = 0 ;
37973
37974   {
37975     try {
37976       result = (Dali::Path::Property *)new Dali::Path::Property();
37977     } catch (std::out_of_range& e) {
37978       {
37979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37980       };
37981     } catch (std::exception& e) {
37982       {
37983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (...) {
37986       {
37987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37988       };
37989     }
37990   }
37991   jresult = (void *)result;
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37997   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37998
37999   arg1 = (Dali::Path::Property *)jarg1;
38000   {
38001     try {
38002       delete arg1;
38003     } catch (std::out_of_range& e) {
38004       {
38005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38006       };
38007     } catch (std::exception& e) {
38008       {
38009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38014       };
38015     }
38016   }
38017 }
38018
38019
38020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38021   void * jresult ;
38022   Dali::Path result;
38023
38024   {
38025     try {
38026       result = Dali::Path::New();
38027     } catch (std::out_of_range& e) {
38028       {
38029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38030       };
38031     } catch (std::exception& e) {
38032       {
38033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38034       };
38035     } catch (...) {
38036       {
38037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38038       };
38039     }
38040   }
38041   jresult = new Dali::Path((const Dali::Path &)result);
38042   return jresult;
38043 }
38044
38045
38046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38047   void * jresult ;
38048   Dali::BaseHandle arg1 ;
38049   Dali::BaseHandle *argp1 ;
38050   Dali::Path result;
38051
38052   argp1 = (Dali::BaseHandle *)jarg1;
38053   if (!argp1) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38055     return 0;
38056   }
38057   arg1 = *argp1;
38058   {
38059     try {
38060       result = Dali::Path::DownCast(arg1);
38061     } catch (std::out_of_range& e) {
38062       {
38063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38064       };
38065     } catch (std::exception& e) {
38066       {
38067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38072       };
38073     }
38074   }
38075   jresult = new Dali::Path((const Dali::Path &)result);
38076   return jresult;
38077 }
38078
38079
38080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38081   void * jresult ;
38082   Dali::Path *result = 0 ;
38083
38084   {
38085     try {
38086       result = (Dali::Path *)new Dali::Path();
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101   jresult = (void *)result;
38102   return jresult;
38103 }
38104
38105
38106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38107   Dali::Path *arg1 = (Dali::Path *) 0 ;
38108
38109   arg1 = (Dali::Path *)jarg1;
38110   {
38111     try {
38112       delete arg1;
38113     } catch (std::out_of_range& e) {
38114       {
38115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38116       };
38117     } catch (std::exception& e) {
38118       {
38119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38120       };
38121     } catch (...) {
38122       {
38123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38124       };
38125     }
38126   }
38127 }
38128
38129
38130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38131   void * jresult ;
38132   Dali::Path *arg1 = 0 ;
38133   Dali::Path *result = 0 ;
38134
38135   arg1 = (Dali::Path *)jarg1;
38136   if (!arg1) {
38137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38138     return 0;
38139   }
38140   {
38141     try {
38142       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38143     } catch (std::out_of_range& e) {
38144       {
38145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38146       };
38147     } catch (std::exception& e) {
38148       {
38149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38150       };
38151     } catch (...) {
38152       {
38153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38154       };
38155     }
38156   }
38157   jresult = (void *)result;
38158   return jresult;
38159 }
38160
38161
38162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38163   void * jresult ;
38164   Dali::Path *arg1 = (Dali::Path *) 0 ;
38165   Dali::Path *arg2 = 0 ;
38166   Dali::Path *result = 0 ;
38167
38168   arg1 = (Dali::Path *)jarg1;
38169   arg2 = (Dali::Path *)jarg2;
38170   if (!arg2) {
38171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38172     return 0;
38173   }
38174   {
38175     try {
38176       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38177     } catch (std::out_of_range& e) {
38178       {
38179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38180       };
38181     } catch (std::exception& e) {
38182       {
38183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (...) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38188       };
38189     }
38190   }
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38197   Dali::Path *arg1 = (Dali::Path *) 0 ;
38198   Dali::Vector3 *arg2 = 0 ;
38199
38200   arg1 = (Dali::Path *)jarg1;
38201   arg2 = (Dali::Vector3 *)jarg2;
38202   if (!arg2) {
38203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38204     return ;
38205   }
38206   {
38207     try {
38208       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38216       };
38217     } catch (...) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38220       };
38221     }
38222   }
38223 }
38224
38225
38226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38227   Dali::Path *arg1 = (Dali::Path *) 0 ;
38228   Dali::Vector3 *arg2 = 0 ;
38229
38230   arg1 = (Dali::Path *)jarg1;
38231   arg2 = (Dali::Vector3 *)jarg2;
38232   if (!arg2) {
38233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38234     return ;
38235   }
38236   {
38237     try {
38238       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38239     } catch (std::out_of_range& e) {
38240       {
38241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38242       };
38243     } catch (std::exception& e) {
38244       {
38245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38246       };
38247     } catch (...) {
38248       {
38249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38250       };
38251     }
38252   }
38253 }
38254
38255
38256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38257   Dali::Path *arg1 = (Dali::Path *) 0 ;
38258   float arg2 ;
38259
38260   arg1 = (Dali::Path *)jarg1;
38261   arg2 = (float)jarg2;
38262   {
38263     try {
38264       (arg1)->GenerateControlPoints(arg2);
38265     } catch (std::out_of_range& e) {
38266       {
38267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38268       };
38269     } catch (std::exception& e) {
38270       {
38271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38272       };
38273     } catch (...) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38276       };
38277     }
38278   }
38279 }
38280
38281
38282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38283   Dali::Path *arg1 = (Dali::Path *) 0 ;
38284   float arg2 ;
38285   Dali::Vector3 *arg3 = 0 ;
38286   Dali::Vector3 *arg4 = 0 ;
38287
38288   arg1 = (Dali::Path *)jarg1;
38289   arg2 = (float)jarg2;
38290   arg3 = (Dali::Vector3 *)jarg3;
38291   if (!arg3) {
38292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38293     return ;
38294   }
38295   arg4 = (Dali::Vector3 *)jarg4;
38296   if (!arg4) {
38297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38298     return ;
38299   }
38300   {
38301     try {
38302       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38314       };
38315     }
38316   }
38317 }
38318
38319
38320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38321   void * jresult ;
38322   Dali::Path *arg1 = (Dali::Path *) 0 ;
38323   size_t arg2 ;
38324   Dali::Vector3 *result = 0 ;
38325
38326   arg1 = (Dali::Path *)jarg1;
38327   arg2 = (size_t)jarg2;
38328   {
38329     try {
38330       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (...) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38342       };
38343     }
38344   }
38345   jresult = (void *)result;
38346   return jresult;
38347 }
38348
38349
38350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38351   void * jresult ;
38352   Dali::Path *arg1 = (Dali::Path *) 0 ;
38353   size_t arg2 ;
38354   Dali::Vector3 *result = 0 ;
38355
38356   arg1 = (Dali::Path *)jarg1;
38357   arg2 = (size_t)jarg2;
38358   {
38359     try {
38360       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375   jresult = (void *)result;
38376   return jresult;
38377 }
38378
38379
38380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38381   unsigned long jresult ;
38382   Dali::Path *arg1 = (Dali::Path *) 0 ;
38383   size_t result;
38384
38385   arg1 = (Dali::Path *)jarg1;
38386   {
38387     try {
38388       result = ((Dali::Path const *)arg1)->GetPointCount();
38389     } catch (std::out_of_range& e) {
38390       {
38391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38392       };
38393     } catch (std::exception& e) {
38394       {
38395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38400       };
38401     }
38402   }
38403   jresult = (unsigned long)result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38409   void * jresult ;
38410   float arg1 ;
38411   Dali::TimePeriod *result = 0 ;
38412
38413   arg1 = (float)jarg1;
38414   {
38415     try {
38416       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (...) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38428       };
38429     }
38430   }
38431   jresult = (void *)result;
38432   return jresult;
38433 }
38434
38435
38436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38437   void * jresult ;
38438   float arg1 ;
38439   float arg2 ;
38440   Dali::TimePeriod *result = 0 ;
38441
38442   arg1 = (float)jarg1;
38443   arg2 = (float)jarg2;
38444   {
38445     try {
38446       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38447     } catch (std::out_of_range& e) {
38448       {
38449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38450       };
38451     } catch (std::exception& e) {
38452       {
38453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (...) {
38456       {
38457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38458       };
38459     }
38460   }
38461   jresult = (void *)result;
38462   return jresult;
38463 }
38464
38465
38466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38467   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38468
38469   arg1 = (Dali::TimePeriod *)jarg1;
38470   {
38471     try {
38472       delete arg1;
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (...) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38484       };
38485     }
38486   }
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38491   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38492   float arg2 ;
38493
38494   arg1 = (Dali::TimePeriod *)jarg1;
38495   arg2 = (float)jarg2;
38496   if (arg1) (arg1)->delaySeconds = arg2;
38497 }
38498
38499
38500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38501   float jresult ;
38502   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38503   float result;
38504
38505   arg1 = (Dali::TimePeriod *)jarg1;
38506   result = (float) ((arg1)->delaySeconds);
38507   jresult = result;
38508   return jresult;
38509 }
38510
38511
38512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38513   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38514   float arg2 ;
38515
38516   arg1 = (Dali::TimePeriod *)jarg1;
38517   arg2 = (float)jarg2;
38518   if (arg1) (arg1)->durationSeconds = arg2;
38519 }
38520
38521
38522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38523   float jresult ;
38524   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38525   float result;
38526
38527   arg1 = (Dali::TimePeriod *)jarg1;
38528   result = (float) ((arg1)->durationSeconds);
38529   jresult = result;
38530   return jresult;
38531 }
38532
38533
38534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38535   void * jresult ;
38536   Dali::Animation *result = 0 ;
38537
38538   {
38539     try {
38540       result = (Dali::Animation *)new Dali::Animation();
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555   jresult = (void *)result;
38556   return jresult;
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38561   void * jresult ;
38562   float arg1 ;
38563   Dali::Animation result;
38564
38565   arg1 = (float)jarg1;
38566   {
38567     try {
38568       result = Dali::Animation::New(arg1);
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583   jresult = new Dali::Animation((const Dali::Animation &)result);
38584   return jresult;
38585 }
38586
38587
38588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38589   void * jresult ;
38590   Dali::BaseHandle arg1 ;
38591   Dali::BaseHandle *argp1 ;
38592   Dali::Animation result;
38593
38594   argp1 = (Dali::BaseHandle *)jarg1;
38595   if (!argp1) {
38596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38597     return 0;
38598   }
38599   arg1 = *argp1;
38600   {
38601     try {
38602       result = Dali::Animation::DownCast(arg1);
38603     } catch (std::out_of_range& e) {
38604       {
38605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38606       };
38607     } catch (std::exception& e) {
38608       {
38609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38614       };
38615     }
38616   }
38617   jresult = new Dali::Animation((const Dali::Animation &)result);
38618   return jresult;
38619 }
38620
38621
38622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38623   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38624
38625   arg1 = (Dali::Animation *)jarg1;
38626   {
38627     try {
38628       delete arg1;
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38640       };
38641     }
38642   }
38643 }
38644
38645
38646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38647   void * jresult ;
38648   Dali::Animation *arg1 = 0 ;
38649   Dali::Animation *result = 0 ;
38650
38651   arg1 = (Dali::Animation *)jarg1;
38652   if (!arg1) {
38653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38654     return 0;
38655   }
38656   {
38657     try {
38658       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38659     } catch (std::out_of_range& e) {
38660       {
38661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38662       };
38663     } catch (std::exception& e) {
38664       {
38665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (...) {
38668       {
38669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38670       };
38671     }
38672   }
38673   jresult = (void *)result;
38674   return jresult;
38675 }
38676
38677
38678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38679   void * jresult ;
38680   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38681   Dali::Animation *arg2 = 0 ;
38682   Dali::Animation *result = 0 ;
38683
38684   arg1 = (Dali::Animation *)jarg1;
38685   arg2 = (Dali::Animation *)jarg2;
38686   if (!arg2) {
38687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38688     return 0;
38689   }
38690   {
38691     try {
38692       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38693     } catch (std::out_of_range& e) {
38694       {
38695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38696       };
38697     } catch (std::exception& e) {
38698       {
38699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (...) {
38702       {
38703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38704       };
38705     }
38706   }
38707   jresult = (void *)result;
38708   return jresult;
38709 }
38710
38711
38712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38713   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38714   float arg2 ;
38715
38716   arg1 = (Dali::Animation *)jarg1;
38717   arg2 = (float)jarg2;
38718   {
38719     try {
38720       (arg1)->SetDuration(arg2);
38721     } catch (std::out_of_range& e) {
38722       {
38723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38724       };
38725     } catch (std::exception& e) {
38726       {
38727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38728       };
38729     } catch (...) {
38730       {
38731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38732       };
38733     }
38734   }
38735 }
38736
38737
38738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38739   float jresult ;
38740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38741   float result;
38742
38743   arg1 = (Dali::Animation *)jarg1;
38744   {
38745     try {
38746       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38747     } catch (std::out_of_range& e) {
38748       {
38749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (std::exception& e) {
38752       {
38753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761   jresult = result;
38762   return jresult;
38763 }
38764
38765
38766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38767   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38768   bool arg2 ;
38769
38770   arg1 = (Dali::Animation *)jarg1;
38771   arg2 = jarg2 ? true : false;
38772   {
38773     try {
38774       (arg1)->SetLooping(arg2);
38775     } catch (std::out_of_range& e) {
38776       {
38777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38778       };
38779     } catch (std::exception& e) {
38780       {
38781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38782       };
38783     } catch (...) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38786       };
38787     }
38788   }
38789 }
38790
38791
38792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   int arg2 ;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   arg2 = (int)jarg2;
38798   {
38799     try {
38800       (arg1)->SetLoopCount(arg2);
38801     } catch (std::out_of_range& e) {
38802       {
38803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38804       };
38805     } catch (std::exception& e) {
38806       {
38807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38808       };
38809     } catch (...) {
38810       {
38811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38812       };
38813     }
38814   }
38815 }
38816
38817
38818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38819   int jresult ;
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   int result;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   {
38825     try {
38826       result = (int)(arg1)->GetLoopCount();
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38838       };
38839     }
38840   }
38841   jresult = result;
38842   return jresult;
38843 }
38844
38845
38846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38847   int jresult ;
38848   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38849   int result;
38850
38851   arg1 = (Dali::Animation *)jarg1;
38852   {
38853     try {
38854       result = (int)(arg1)->GetCurrentLoop();
38855     } catch (std::out_of_range& e) {
38856       {
38857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38858       };
38859     } catch (std::exception& e) {
38860       {
38861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38862       };
38863     } catch (...) {
38864       {
38865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38866       };
38867     }
38868   }
38869   jresult = result;
38870   return jresult;
38871 }
38872
38873
38874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38875   unsigned int jresult ;
38876   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38877   bool result;
38878
38879   arg1 = (Dali::Animation *)jarg1;
38880   {
38881     try {
38882       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38883     } catch (std::out_of_range& e) {
38884       {
38885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (std::exception& e) {
38888       {
38889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897   jresult = result;
38898   return jresult;
38899 }
38900
38901
38902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38903   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38904   Dali::Animation::EndAction arg2 ;
38905
38906   arg1 = (Dali::Animation *)jarg1;
38907   arg2 = (Dali::Animation::EndAction)jarg2;
38908   {
38909     try {
38910       (arg1)->SetEndAction(arg2);
38911     } catch (std::out_of_range& e) {
38912       {
38913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38914       };
38915     } catch (std::exception& e) {
38916       {
38917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38918       };
38919     } catch (...) {
38920       {
38921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38922       };
38923     }
38924   }
38925 }
38926
38927
38928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38929   int jresult ;
38930   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38931   Dali::Animation::EndAction result;
38932
38933   arg1 = (Dali::Animation *)jarg1;
38934   {
38935     try {
38936       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38937     } catch (std::out_of_range& e) {
38938       {
38939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38940       };
38941     } catch (std::exception& e) {
38942       {
38943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38944       };
38945     } catch (...) {
38946       {
38947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38948       };
38949     }
38950   }
38951   jresult = (int)result;
38952   return jresult;
38953 }
38954
38955
38956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38957   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38958   Dali::Animation::EndAction arg2 ;
38959
38960   arg1 = (Dali::Animation *)jarg1;
38961   arg2 = (Dali::Animation::EndAction)jarg2;
38962   {
38963     try {
38964       (arg1)->SetDisconnectAction(arg2);
38965     } catch (std::out_of_range& e) {
38966       {
38967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38968       };
38969     } catch (std::exception& e) {
38970       {
38971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38972       };
38973     } catch (...) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38976       };
38977     }
38978   }
38979 }
38980
38981
38982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38983   int jresult ;
38984   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38985   Dali::Animation::EndAction result;
38986
38987   arg1 = (Dali::Animation *)jarg1;
38988   {
38989     try {
38990       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38991     } catch (std::out_of_range& e) {
38992       {
38993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38994       };
38995     } catch (std::exception& e) {
38996       {
38997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38998       };
38999     } catch (...) {
39000       {
39001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39002       };
39003     }
39004   }
39005   jresult = (int)result;
39006   return jresult;
39007 }
39008
39009
39010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39011   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39012   Dali::AlphaFunction arg2 ;
39013   Dali::AlphaFunction *argp2 ;
39014
39015   arg1 = (Dali::Animation *)jarg1;
39016   argp2 = (Dali::AlphaFunction *)jarg2;
39017   if (!argp2) {
39018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39019     return ;
39020   }
39021   arg2 = *argp2;
39022   {
39023     try {
39024       (arg1)->SetDefaultAlphaFunction(arg2);
39025     } catch (std::out_of_range& e) {
39026       {
39027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (std::exception& e) {
39030       {
39031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39036       };
39037     }
39038   }
39039 }
39040
39041
39042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39043   void * jresult ;
39044   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39045   Dali::AlphaFunction result;
39046
39047   arg1 = (Dali::Animation *)jarg1;
39048   {
39049     try {
39050       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39051     } catch (std::out_of_range& e) {
39052       {
39053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39054       };
39055     } catch (std::exception& e) {
39056       {
39057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39058       };
39059     } catch (...) {
39060       {
39061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39062       };
39063     }
39064   }
39065   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39066   return jresult;
39067 }
39068
39069
39070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39071   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39072   float arg2 ;
39073
39074   arg1 = (Dali::Animation *)jarg1;
39075   arg2 = (float)jarg2;
39076   {
39077     try {
39078       (arg1)->SetCurrentProgress(arg2);
39079     } catch (std::out_of_range& e) {
39080       {
39081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39082       };
39083     } catch (std::exception& e) {
39084       {
39085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39090       };
39091     }
39092   }
39093 }
39094
39095
39096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39097   float jresult ;
39098   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39099   float result;
39100
39101   arg1 = (Dali::Animation *)jarg1;
39102   {
39103     try {
39104       result = (float)(arg1)->GetCurrentProgress();
39105     } catch (std::out_of_range& e) {
39106       {
39107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (std::exception& e) {
39110       {
39111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119   jresult = result;
39120   return jresult;
39121 }
39122
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39125   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39126   float arg2 ;
39127
39128   arg1 = (Dali::Animation *)jarg1;
39129   arg2 = (float)jarg2;
39130   {
39131     try {
39132       (arg1)->SetSpeedFactor(arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39144       };
39145     }
39146   }
39147 }
39148
39149
39150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39151   float jresult ;
39152   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39153   float result;
39154
39155   arg1 = (Dali::Animation *)jarg1;
39156   {
39157     try {
39158       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39159     } catch (std::out_of_range& e) {
39160       {
39161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39162       };
39163     } catch (std::exception& e) {
39164       {
39165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39166       };
39167     } catch (...) {
39168       {
39169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39170       };
39171     }
39172   }
39173   jresult = result;
39174   return jresult;
39175 }
39176
39177
39178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39179   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39180   Dali::Vector2 *arg2 = 0 ;
39181
39182   arg1 = (Dali::Animation *)jarg1;
39183   arg2 = (Dali::Vector2 *)jarg2;
39184   if (!arg2) {
39185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39186     return ;
39187   }
39188   {
39189     try {
39190       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39191     } catch (std::out_of_range& e) {
39192       {
39193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39194       };
39195     } catch (std::exception& e) {
39196       {
39197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39198       };
39199     } catch (...) {
39200       {
39201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39202       };
39203     }
39204   }
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39209   void * jresult ;
39210   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39211   Dali::Vector2 result;
39212
39213   arg1 = (Dali::Animation *)jarg1;
39214   {
39215     try {
39216       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (...) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39228       };
39229     }
39230   }
39231   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39237   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39238
39239   arg1 = (Dali::Animation *)jarg1;
39240   {
39241     try {
39242       (arg1)->Play();
39243     } catch (std::out_of_range& e) {
39244       {
39245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (std::exception& e) {
39248       {
39249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257 }
39258
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39261   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39262   float arg2 ;
39263
39264   arg1 = (Dali::Animation *)jarg1;
39265   arg2 = (float)jarg2;
39266   {
39267     try {
39268       (arg1)->PlayFrom(arg2);
39269     } catch (std::out_of_range& e) {
39270       {
39271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (std::exception& e) {
39274       {
39275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283 }
39284
39285
39286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39287   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39288
39289   arg1 = (Dali::Animation *)jarg1;
39290   {
39291     try {
39292       (arg1)->Pause();
39293     } catch (std::out_of_range& e) {
39294       {
39295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39296       };
39297     } catch (std::exception& e) {
39298       {
39299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39300       };
39301     } catch (...) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39304       };
39305     }
39306   }
39307 }
39308
39309
39310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39311   int jresult ;
39312   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39313   Dali::Animation::State result;
39314
39315   arg1 = (Dali::Animation *)jarg1;
39316   {
39317     try {
39318       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39319     } catch (std::out_of_range& e) {
39320       {
39321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (std::exception& e) {
39324       {
39325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39326       };
39327     } catch (...) {
39328       {
39329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39330       };
39331     }
39332   }
39333   jresult = (int)result;
39334   return jresult;
39335 }
39336
39337
39338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39339   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39340
39341   arg1 = (Dali::Animation *)jarg1;
39342   {
39343     try {
39344       (arg1)->Stop();
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (...) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39356       };
39357     }
39358   }
39359 }
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39362   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39363
39364   Dali::Animation arg1 = *argp1;
39365   float arg2 = (float)jarg2;
39366
39367   {
39368     try {
39369       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39370     } catch (std::out_of_range& e) {
39371       {
39372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (std::exception& e) {
39375       {
39376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39377       };
39378     } catch (...) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39381       };
39382     }
39383   }
39384 }
39385
39386
39387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39388   float jresult ;
39389   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39390   float result;
39391
39392   Dali::Animation arg1 = *argp1;
39393   {
39394     try {
39395       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
39396     } catch (std::out_of_range& e) {
39397       {
39398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (std::exception& e) {
39401       {
39402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39407       };
39408     }
39409   }
39410   jresult = result;
39411   return jresult;
39412 }
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39415   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39416
39417   arg1 = (Dali::Animation *)jarg1;
39418   {
39419     try {
39420       (arg1)->Clear();
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39432       };
39433     }
39434   }
39435 }
39436
39437
39438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39439   void * jresult ;
39440   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39441   Dali::Animation::AnimationSignalType *result = 0 ;
39442
39443   arg1 = (Dali::Animation *)jarg1;
39444   {
39445     try {
39446       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (...) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39458       };
39459     }
39460   }
39461   jresult = (void *)result;
39462   return jresult;
39463 }
39464
39465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39466   void * jresult ;
39467   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39468   Dali::Animation::AnimationSignalType *result = 0 ;
39469
39470   Dali::Animation arg1 = *argp1;
39471   {
39472     try {
39473       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39474     } catch (std::out_of_range& e) {
39475       {
39476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39477       };
39478     } catch (std::exception& e) {
39479       {
39480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39481       };
39482     } catch (...) {
39483       {
39484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39485       };
39486     }
39487   }
39488   jresult = (void *)result;
39489   return jresult;
39490 }
39491
39492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39493   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39494   SwigValueWrapper< Dali::Property > arg2 ;
39495   Dali::Property::Value arg3 ;
39496   Dali::Property *argp2 ;
39497   Dali::Property::Value *argp3 ;
39498
39499   arg1 = (Dali::Animation *)jarg1;
39500   argp2 = (Dali::Property *)jarg2;
39501   if (!argp2) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39503     return ;
39504   }
39505   arg2 = *argp2;
39506   argp3 = (Dali::Property::Value *)jarg3;
39507   if (!argp3) {
39508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39509     return ;
39510   }
39511   arg3 = *argp3;
39512   {
39513     try {
39514       (arg1)->AnimateBy(arg2,arg3);
39515     } catch (std::out_of_range& e) {
39516       {
39517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39518       };
39519     } catch (std::exception& e) {
39520       {
39521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39522       };
39523     } catch (...) {
39524       {
39525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39526       };
39527     }
39528   }
39529 }
39530
39531
39532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39533   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39534   SwigValueWrapper< Dali::Property > arg2 ;
39535   Dali::Property::Value arg3 ;
39536   Dali::AlphaFunction arg4 ;
39537   Dali::Property *argp2 ;
39538   Dali::Property::Value *argp3 ;
39539   Dali::AlphaFunction *argp4 ;
39540
39541   arg1 = (Dali::Animation *)jarg1;
39542   argp2 = (Dali::Property *)jarg2;
39543   if (!argp2) {
39544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39545     return ;
39546   }
39547   arg2 = *argp2;
39548   argp3 = (Dali::Property::Value *)jarg3;
39549   if (!argp3) {
39550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39551     return ;
39552   }
39553   arg3 = *argp3;
39554   argp4 = (Dali::AlphaFunction *)jarg4;
39555   if (!argp4) {
39556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39557     return ;
39558   }
39559   arg4 = *argp4;
39560   {
39561     try {
39562       (arg1)->AnimateBy(arg2,arg3,arg4);
39563     } catch (std::out_of_range& e) {
39564       {
39565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39566       };
39567     } catch (std::exception& e) {
39568       {
39569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39574       };
39575     }
39576   }
39577 }
39578
39579
39580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39581   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39582   SwigValueWrapper< Dali::Property > arg2 ;
39583   Dali::Property::Value arg3 ;
39584   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39585   Dali::Property *argp2 ;
39586   Dali::Property::Value *argp3 ;
39587   Dali::TimePeriod *argp4 ;
39588
39589   arg1 = (Dali::Animation *)jarg1;
39590   argp2 = (Dali::Property *)jarg2;
39591   if (!argp2) {
39592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39593     return ;
39594   }
39595   arg2 = *argp2;
39596   argp3 = (Dali::Property::Value *)jarg3;
39597   if (!argp3) {
39598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39599     return ;
39600   }
39601   arg3 = *argp3;
39602   argp4 = (Dali::TimePeriod *)jarg4;
39603   if (!argp4) {
39604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39605     return ;
39606   }
39607   arg4 = *argp4;
39608   {
39609     try {
39610       (arg1)->AnimateBy(arg2,arg3,arg4);
39611     } catch (std::out_of_range& e) {
39612       {
39613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39614       };
39615     } catch (std::exception& e) {
39616       {
39617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39618       };
39619     } catch (...) {
39620       {
39621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39622       };
39623     }
39624   }
39625 }
39626
39627
39628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39629   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39630   SwigValueWrapper< Dali::Property > arg2 ;
39631   Dali::Property::Value arg3 ;
39632   Dali::AlphaFunction arg4 ;
39633   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39634   Dali::Property *argp2 ;
39635   Dali::Property::Value *argp3 ;
39636   Dali::AlphaFunction *argp4 ;
39637   Dali::TimePeriod *argp5 ;
39638
39639   arg1 = (Dali::Animation *)jarg1;
39640   argp2 = (Dali::Property *)jarg2;
39641   if (!argp2) {
39642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39643     return ;
39644   }
39645   arg2 = *argp2;
39646   argp3 = (Dali::Property::Value *)jarg3;
39647   if (!argp3) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39649     return ;
39650   }
39651   arg3 = *argp3;
39652   argp4 = (Dali::AlphaFunction *)jarg4;
39653   if (!argp4) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39655     return ;
39656   }
39657   arg4 = *argp4;
39658   argp5 = (Dali::TimePeriod *)jarg5;
39659   if (!argp5) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39661     return ;
39662   }
39663   arg5 = *argp5;
39664   {
39665     try {
39666       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39667     } catch (std::out_of_range& e) {
39668       {
39669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39670       };
39671     } catch (std::exception& e) {
39672       {
39673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39674       };
39675     } catch (...) {
39676       {
39677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39678       };
39679     }
39680   }
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39685   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39686   SwigValueWrapper< Dali::Property > arg2 ;
39687   Dali::Property::Value arg3 ;
39688   Dali::Property *argp2 ;
39689   Dali::Property::Value *argp3 ;
39690
39691   arg1 = (Dali::Animation *)jarg1;
39692   argp2 = (Dali::Property *)jarg2;
39693   if (!argp2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39695     return ;
39696   }
39697   arg2 = *argp2;
39698   argp3 = (Dali::Property::Value *)jarg3;
39699   if (!argp3) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39701     return ;
39702   }
39703   arg3 = *argp3;
39704   {
39705     try {
39706       (arg1)->AnimateTo(arg2,arg3);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721 }
39722
39723
39724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39725   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39726   SwigValueWrapper< Dali::Property > arg2 ;
39727   Dali::Property::Value arg3 ;
39728   Dali::AlphaFunction arg4 ;
39729   Dali::Property *argp2 ;
39730   Dali::Property::Value *argp3 ;
39731   Dali::AlphaFunction *argp4 ;
39732
39733   arg1 = (Dali::Animation *)jarg1;
39734   argp2 = (Dali::Property *)jarg2;
39735   if (!argp2) {
39736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39737     return ;
39738   }
39739   arg2 = *argp2;
39740   argp3 = (Dali::Property::Value *)jarg3;
39741   if (!argp3) {
39742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39743     return ;
39744   }
39745   arg3 = *argp3;
39746   argp4 = (Dali::AlphaFunction *)jarg4;
39747   if (!argp4) {
39748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39749     return ;
39750   }
39751   arg4 = *argp4;
39752   {
39753     try {
39754       (arg1)->AnimateTo(arg2,arg3,arg4);
39755     } catch (std::out_of_range& e) {
39756       {
39757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (std::exception& e) {
39760       {
39761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769 }
39770
39771
39772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39773   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39774   SwigValueWrapper< Dali::Property > arg2 ;
39775   Dali::Property::Value arg3 ;
39776   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39777   Dali::Property *argp2 ;
39778   Dali::Property::Value *argp3 ;
39779   Dali::TimePeriod *argp4 ;
39780
39781   arg1 = (Dali::Animation *)jarg1;
39782   argp2 = (Dali::Property *)jarg2;
39783   if (!argp2) {
39784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39785     return ;
39786   }
39787   arg2 = *argp2;
39788   argp3 = (Dali::Property::Value *)jarg3;
39789   if (!argp3) {
39790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39791     return ;
39792   }
39793   arg3 = *argp3;
39794   argp4 = (Dali::TimePeriod *)jarg4;
39795   if (!argp4) {
39796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39797     return ;
39798   }
39799   arg4 = *argp4;
39800   {
39801     try {
39802       (arg1)->AnimateTo(arg2,arg3,arg4);
39803     } catch (std::out_of_range& e) {
39804       {
39805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39806       };
39807     } catch (std::exception& e) {
39808       {
39809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39810       };
39811     } catch (...) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39814       };
39815     }
39816   }
39817 }
39818
39819
39820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39821   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39822   SwigValueWrapper< Dali::Property > arg2 ;
39823   Dali::Property::Value arg3 ;
39824   Dali::AlphaFunction arg4 ;
39825   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39826   Dali::Property *argp2 ;
39827   Dali::Property::Value *argp3 ;
39828   Dali::AlphaFunction *argp4 ;
39829   Dali::TimePeriod *argp5 ;
39830
39831   arg1 = (Dali::Animation *)jarg1;
39832   argp2 = (Dali::Property *)jarg2;
39833   if (!argp2) {
39834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39835     return ;
39836   }
39837   arg2 = *argp2;
39838   argp3 = (Dali::Property::Value *)jarg3;
39839   if (!argp3) {
39840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39841     return ;
39842   }
39843   arg3 = *argp3;
39844   argp4 = (Dali::AlphaFunction *)jarg4;
39845   if (!argp4) {
39846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39847     return ;
39848   }
39849   arg4 = *argp4;
39850   argp5 = (Dali::TimePeriod *)jarg5;
39851   if (!argp5) {
39852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39853     return ;
39854   }
39855   arg5 = *argp5;
39856   {
39857     try {
39858       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39859     } catch (std::out_of_range& e) {
39860       {
39861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39862       };
39863     } catch (std::exception& e) {
39864       {
39865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39866       };
39867     } catch (...) {
39868       {
39869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39870       };
39871     }
39872   }
39873 }
39874
39875
39876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39877   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39878   SwigValueWrapper< Dali::Property > arg2 ;
39879   Dali::KeyFrames *arg3 = 0 ;
39880   Dali::Property *argp2 ;
39881
39882   arg1 = (Dali::Animation *)jarg1;
39883   argp2 = (Dali::Property *)jarg2;
39884   if (!argp2) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39886     return ;
39887   }
39888   arg2 = *argp2;
39889   arg3 = (Dali::KeyFrames *)jarg3;
39890   if (!arg3) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39892     return ;
39893   }
39894   {
39895     try {
39896       (arg1)->AnimateBetween(arg2,*arg3);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911 }
39912
39913
39914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39915   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39916   SwigValueWrapper< Dali::Property > arg2 ;
39917   Dali::KeyFrames *arg3 = 0 ;
39918   Dali::Animation::Interpolation arg4 ;
39919   Dali::Property *argp2 ;
39920
39921   arg1 = (Dali::Animation *)jarg1;
39922   argp2 = (Dali::Property *)jarg2;
39923   if (!argp2) {
39924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39925     return ;
39926   }
39927   arg2 = *argp2;
39928   arg3 = (Dali::KeyFrames *)jarg3;
39929   if (!arg3) {
39930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39931     return ;
39932   }
39933   arg4 = (Dali::Animation::Interpolation)jarg4;
39934   {
39935     try {
39936       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39937     } catch (std::out_of_range& e) {
39938       {
39939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39940       };
39941     } catch (std::exception& e) {
39942       {
39943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39944       };
39945     } catch (...) {
39946       {
39947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39948       };
39949     }
39950   }
39951 }
39952
39953
39954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39955   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39956   SwigValueWrapper< Dali::Property > arg2 ;
39957   Dali::KeyFrames *arg3 = 0 ;
39958   Dali::AlphaFunction arg4 ;
39959   Dali::Property *argp2 ;
39960   Dali::AlphaFunction *argp4 ;
39961
39962   arg1 = (Dali::Animation *)jarg1;
39963   argp2 = (Dali::Property *)jarg2;
39964   if (!argp2) {
39965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39966     return ;
39967   }
39968   arg2 = *argp2;
39969   arg3 = (Dali::KeyFrames *)jarg3;
39970   if (!arg3) {
39971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39972     return ;
39973   }
39974   argp4 = (Dali::AlphaFunction *)jarg4;
39975   if (!argp4) {
39976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39977     return ;
39978   }
39979   arg4 = *argp4;
39980   {
39981     try {
39982       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39983     } catch (std::out_of_range& e) {
39984       {
39985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (std::exception& e) {
39988       {
39989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997 }
39998
39999
40000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40001   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40002   SwigValueWrapper< Dali::Property > arg2 ;
40003   Dali::KeyFrames *arg3 = 0 ;
40004   Dali::AlphaFunction arg4 ;
40005   Dali::Animation::Interpolation arg5 ;
40006   Dali::Property *argp2 ;
40007   Dali::AlphaFunction *argp4 ;
40008
40009   arg1 = (Dali::Animation *)jarg1;
40010   argp2 = (Dali::Property *)jarg2;
40011   if (!argp2) {
40012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40013     return ;
40014   }
40015   arg2 = *argp2;
40016   arg3 = (Dali::KeyFrames *)jarg3;
40017   if (!arg3) {
40018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40019     return ;
40020   }
40021   argp4 = (Dali::AlphaFunction *)jarg4;
40022   if (!argp4) {
40023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40024     return ;
40025   }
40026   arg4 = *argp4;
40027   arg5 = (Dali::Animation::Interpolation)jarg5;
40028   {
40029     try {
40030       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40031     } catch (std::out_of_range& e) {
40032       {
40033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40034       };
40035     } catch (std::exception& e) {
40036       {
40037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40042       };
40043     }
40044   }
40045 }
40046
40047
40048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40049   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40050   SwigValueWrapper< Dali::Property > arg2 ;
40051   Dali::KeyFrames *arg3 = 0 ;
40052   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40053   Dali::Property *argp2 ;
40054   Dali::TimePeriod *argp4 ;
40055
40056   arg1 = (Dali::Animation *)jarg1;
40057   argp2 = (Dali::Property *)jarg2;
40058   if (!argp2) {
40059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40060     return ;
40061   }
40062   arg2 = *argp2;
40063   arg3 = (Dali::KeyFrames *)jarg3;
40064   if (!arg3) {
40065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40066     return ;
40067   }
40068   argp4 = (Dali::TimePeriod *)jarg4;
40069   if (!argp4) {
40070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40071     return ;
40072   }
40073   arg4 = *argp4;
40074   {
40075     try {
40076       (arg1)->AnimateBetween(arg2,*arg3,arg4);
40077     } catch (std::out_of_range& e) {
40078       {
40079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40080       };
40081     } catch (std::exception& e) {
40082       {
40083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40084       };
40085     } catch (...) {
40086       {
40087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40088       };
40089     }
40090   }
40091 }
40092
40093
40094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40096   SwigValueWrapper< Dali::Property > arg2 ;
40097   Dali::KeyFrames *arg3 = 0 ;
40098   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40099   Dali::Animation::Interpolation arg5 ;
40100   Dali::Property *argp2 ;
40101   Dali::TimePeriod *argp4 ;
40102
40103   arg1 = (Dali::Animation *)jarg1;
40104   argp2 = (Dali::Property *)jarg2;
40105   if (!argp2) {
40106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40107     return ;
40108   }
40109   arg2 = *argp2;
40110   arg3 = (Dali::KeyFrames *)jarg3;
40111   if (!arg3) {
40112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40113     return ;
40114   }
40115   argp4 = (Dali::TimePeriod *)jarg4;
40116   if (!argp4) {
40117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40118     return ;
40119   }
40120   arg4 = *argp4;
40121   arg5 = (Dali::Animation::Interpolation)jarg5;
40122   {
40123     try {
40124       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40125     } catch (std::out_of_range& e) {
40126       {
40127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40128       };
40129     } catch (std::exception& e) {
40130       {
40131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40136       };
40137     }
40138   }
40139 }
40140
40141
40142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40143   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40144   SwigValueWrapper< Dali::Property > arg2 ;
40145   Dali::KeyFrames *arg3 = 0 ;
40146   Dali::AlphaFunction arg4 ;
40147   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40148   Dali::Property *argp2 ;
40149   Dali::AlphaFunction *argp4 ;
40150   Dali::TimePeriod *argp5 ;
40151
40152   arg1 = (Dali::Animation *)jarg1;
40153   argp2 = (Dali::Property *)jarg2;
40154   if (!argp2) {
40155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40156     return ;
40157   }
40158   arg2 = *argp2;
40159   arg3 = (Dali::KeyFrames *)jarg3;
40160   if (!arg3) {
40161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40162     return ;
40163   }
40164   argp4 = (Dali::AlphaFunction *)jarg4;
40165   if (!argp4) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40167     return ;
40168   }
40169   arg4 = *argp4;
40170   argp5 = (Dali::TimePeriod *)jarg5;
40171   if (!argp5) {
40172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40173     return ;
40174   }
40175   arg5 = *argp5;
40176   {
40177     try {
40178       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40186       };
40187     } catch (...) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40190       };
40191     }
40192   }
40193 }
40194
40195
40196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40197   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40198   SwigValueWrapper< Dali::Property > arg2 ;
40199   Dali::KeyFrames *arg3 = 0 ;
40200   Dali::AlphaFunction arg4 ;
40201   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40202   Dali::Animation::Interpolation arg6 ;
40203   Dali::Property *argp2 ;
40204   Dali::AlphaFunction *argp4 ;
40205   Dali::TimePeriod *argp5 ;
40206
40207   arg1 = (Dali::Animation *)jarg1;
40208   argp2 = (Dali::Property *)jarg2;
40209   if (!argp2) {
40210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40211     return ;
40212   }
40213   arg2 = *argp2;
40214   arg3 = (Dali::KeyFrames *)jarg3;
40215   if (!arg3) {
40216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40217     return ;
40218   }
40219   argp4 = (Dali::AlphaFunction *)jarg4;
40220   if (!argp4) {
40221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40222     return ;
40223   }
40224   arg4 = *argp4;
40225   argp5 = (Dali::TimePeriod *)jarg5;
40226   if (!argp5) {
40227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40228     return ;
40229   }
40230   arg5 = *argp5;
40231   arg6 = (Dali::Animation::Interpolation)jarg6;
40232   {
40233     try {
40234       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40246       };
40247     }
40248   }
40249 }
40250
40251
40252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40253   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40254   Dali::Actor arg2 ;
40255   Dali::Path arg3 ;
40256   Dali::Vector3 *arg4 = 0 ;
40257   Dali::Actor *argp2 ;
40258   Dali::Path *argp3 ;
40259
40260   arg1 = (Dali::Animation *)jarg1;
40261   argp2 = (Dali::Actor *)jarg2;
40262   if (!argp2) {
40263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40264     return ;
40265   }
40266   arg2 = *argp2;
40267   argp3 = (Dali::Path *)jarg3;
40268   if (!argp3) {
40269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40270     return ;
40271   }
40272   arg3 = *argp3;
40273   arg4 = (Dali::Vector3 *)jarg4;
40274   if (!arg4) {
40275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40276     return ;
40277   }
40278   {
40279     try {
40280       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40281     } catch (std::out_of_range& e) {
40282       {
40283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40284       };
40285     } catch (std::exception& e) {
40286       {
40287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40288       };
40289     } catch (...) {
40290       {
40291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40292       };
40293     }
40294   }
40295 }
40296
40297
40298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40299   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40300   Dali::Actor arg2 ;
40301   Dali::Path arg3 ;
40302   Dali::Vector3 *arg4 = 0 ;
40303   Dali::AlphaFunction arg5 ;
40304   Dali::Actor *argp2 ;
40305   Dali::Path *argp3 ;
40306   Dali::AlphaFunction *argp5 ;
40307
40308   arg1 = (Dali::Animation *)jarg1;
40309   argp2 = (Dali::Actor *)jarg2;
40310   if (!argp2) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40312     return ;
40313   }
40314   arg2 = *argp2;
40315   argp3 = (Dali::Path *)jarg3;
40316   if (!argp3) {
40317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40318     return ;
40319   }
40320   arg3 = *argp3;
40321   arg4 = (Dali::Vector3 *)jarg4;
40322   if (!arg4) {
40323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40324     return ;
40325   }
40326   argp5 = (Dali::AlphaFunction *)jarg5;
40327   if (!argp5) {
40328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40329     return ;
40330   }
40331   arg5 = *argp5;
40332   {
40333     try {
40334       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40335     } catch (std::out_of_range& e) {
40336       {
40337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40338       };
40339     } catch (std::exception& e) {
40340       {
40341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40342       };
40343     } catch (...) {
40344       {
40345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40346       };
40347     }
40348   }
40349 }
40350
40351
40352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40353   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40354   Dali::Actor arg2 ;
40355   Dali::Path arg3 ;
40356   Dali::Vector3 *arg4 = 0 ;
40357   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40358   Dali::Actor *argp2 ;
40359   Dali::Path *argp3 ;
40360   Dali::TimePeriod *argp5 ;
40361
40362   arg1 = (Dali::Animation *)jarg1;
40363   argp2 = (Dali::Actor *)jarg2;
40364   if (!argp2) {
40365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40366     return ;
40367   }
40368   arg2 = *argp2;
40369   argp3 = (Dali::Path *)jarg3;
40370   if (!argp3) {
40371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40372     return ;
40373   }
40374   arg3 = *argp3;
40375   arg4 = (Dali::Vector3 *)jarg4;
40376   if (!arg4) {
40377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40378     return ;
40379   }
40380   argp5 = (Dali::TimePeriod *)jarg5;
40381   if (!argp5) {
40382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40383     return ;
40384   }
40385   arg5 = *argp5;
40386   {
40387     try {
40388       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40389     } catch (std::out_of_range& e) {
40390       {
40391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40392       };
40393     } catch (std::exception& e) {
40394       {
40395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40396       };
40397     } catch (...) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40400       };
40401     }
40402   }
40403 }
40404
40405
40406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40407   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40408   Dali::Actor arg2 ;
40409   Dali::Path arg3 ;
40410   Dali::Vector3 *arg4 = 0 ;
40411   Dali::AlphaFunction arg5 ;
40412   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40413   Dali::Actor *argp2 ;
40414   Dali::Path *argp3 ;
40415   Dali::AlphaFunction *argp5 ;
40416   Dali::TimePeriod *argp6 ;
40417
40418   arg1 = (Dali::Animation *)jarg1;
40419   argp2 = (Dali::Actor *)jarg2;
40420   if (!argp2) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40422     return ;
40423   }
40424   arg2 = *argp2;
40425   argp3 = (Dali::Path *)jarg3;
40426   if (!argp3) {
40427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40428     return ;
40429   }
40430   arg3 = *argp3;
40431   arg4 = (Dali::Vector3 *)jarg4;
40432   if (!arg4) {
40433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40434     return ;
40435   }
40436   argp5 = (Dali::AlphaFunction *)jarg5;
40437   if (!argp5) {
40438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40439     return ;
40440   }
40441   arg5 = *argp5;
40442   argp6 = (Dali::TimePeriod *)jarg6;
40443   if (!argp6) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40445     return ;
40446   }
40447   arg6 = *argp6;
40448   {
40449     try {
40450       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40451     } catch (std::out_of_range& e) {
40452       {
40453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40454       };
40455     } catch (std::exception& e) {
40456       {
40457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (...) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40462       };
40463     }
40464   }
40465 }
40466
40467
40468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40469   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40470   Dali::Actor arg2 ;
40471   float arg3 ;
40472   Dali::Actor *argp2 ;
40473
40474   arg1 = (Dali::Animation *)jarg1;
40475   argp2 = (Dali::Actor *)jarg2;
40476   if (!argp2) {
40477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40478     return ;
40479   }
40480   arg2 = *argp2;
40481   arg3 = (float)jarg3;
40482   {
40483     try {
40484       (arg1)->Show(arg2,arg3);
40485     } catch (std::out_of_range& e) {
40486       {
40487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40488       };
40489     } catch (std::exception& e) {
40490       {
40491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (...) {
40494       {
40495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40496       };
40497     }
40498   }
40499 }
40500
40501
40502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40503   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40504   Dali::Actor arg2 ;
40505   float arg3 ;
40506   Dali::Actor *argp2 ;
40507
40508   arg1 = (Dali::Animation *)jarg1;
40509   argp2 = (Dali::Actor *)jarg2;
40510   if (!argp2) {
40511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40512     return ;
40513   }
40514   arg2 = *argp2;
40515   arg3 = (float)jarg3;
40516   {
40517     try {
40518       (arg1)->Hide(arg2,arg3);
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40526       };
40527     } catch (...) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40530       };
40531     }
40532   }
40533 }
40534
40535
40536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40537   int jresult ;
40538   int result;
40539
40540   result = (int)Dali::LinearConstrainer::Property::VALUE;
40541   jresult = (int)result;
40542   return jresult;
40543 }
40544
40545
40546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40547   int jresult ;
40548   int result;
40549
40550   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40551   jresult = (int)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40557   void * jresult ;
40558   Dali::LinearConstrainer::Property *result = 0 ;
40559
40560   {
40561     try {
40562       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577   jresult = (void *)result;
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40583   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40584
40585   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40586   {
40587     try {
40588       delete arg1;
40589     } catch (std::out_of_range& e) {
40590       {
40591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40592       };
40593     } catch (std::exception& e) {
40594       {
40595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40596       };
40597     } catch (...) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40600       };
40601     }
40602   }
40603 }
40604
40605
40606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40607   void * jresult ;
40608   Dali::LinearConstrainer result;
40609
40610   {
40611     try {
40612       result = Dali::LinearConstrainer::New();
40613     } catch (std::out_of_range& e) {
40614       {
40615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40616       };
40617     } catch (std::exception& e) {
40618       {
40619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40620       };
40621     } catch (...) {
40622       {
40623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40624       };
40625     }
40626   }
40627   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40628   return jresult;
40629 }
40630
40631
40632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40633   void * jresult ;
40634   Dali::BaseHandle arg1 ;
40635   Dali::BaseHandle *argp1 ;
40636   Dali::LinearConstrainer result;
40637
40638   argp1 = (Dali::BaseHandle *)jarg1;
40639   if (!argp1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40641     return 0;
40642   }
40643   arg1 = *argp1;
40644   {
40645     try {
40646       result = Dali::LinearConstrainer::DownCast(arg1);
40647     } catch (std::out_of_range& e) {
40648       {
40649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40650       };
40651     } catch (std::exception& e) {
40652       {
40653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40654       };
40655     } catch (...) {
40656       {
40657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40658       };
40659     }
40660   }
40661   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40662   return jresult;
40663 }
40664
40665
40666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40667   void * jresult ;
40668   Dali::LinearConstrainer *result = 0 ;
40669
40670   {
40671     try {
40672       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40673     } catch (std::out_of_range& e) {
40674       {
40675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40676       };
40677     } catch (std::exception& e) {
40678       {
40679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40680       };
40681     } catch (...) {
40682       {
40683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40684       };
40685     }
40686   }
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40693   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40694
40695   arg1 = (Dali::LinearConstrainer *)jarg1;
40696   {
40697     try {
40698       delete arg1;
40699     } catch (std::out_of_range& e) {
40700       {
40701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40702       };
40703     } catch (std::exception& e) {
40704       {
40705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40706       };
40707     } catch (...) {
40708       {
40709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40710       };
40711     }
40712   }
40713 }
40714
40715
40716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40717   void * jresult ;
40718   Dali::LinearConstrainer *arg1 = 0 ;
40719   Dali::LinearConstrainer *result = 0 ;
40720
40721   arg1 = (Dali::LinearConstrainer *)jarg1;
40722   if (!arg1) {
40723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40724     return 0;
40725   }
40726   {
40727     try {
40728       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40729     } catch (std::out_of_range& e) {
40730       {
40731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40732       };
40733     } catch (std::exception& e) {
40734       {
40735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40740       };
40741     }
40742   }
40743   jresult = (void *)result;
40744   return jresult;
40745 }
40746
40747
40748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40749   void * jresult ;
40750   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40751   Dali::LinearConstrainer *arg2 = 0 ;
40752   Dali::LinearConstrainer *result = 0 ;
40753
40754   arg1 = (Dali::LinearConstrainer *)jarg1;
40755   arg2 = (Dali::LinearConstrainer *)jarg2;
40756   if (!arg2) {
40757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40758     return 0;
40759   }
40760   {
40761     try {
40762       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40774       };
40775     }
40776   }
40777   jresult = (void *)result;
40778   return jresult;
40779 }
40780
40781
40782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40783   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40784   SwigValueWrapper< Dali::Property > arg2 ;
40785   SwigValueWrapper< Dali::Property > arg3 ;
40786   Dali::Vector2 *arg4 = 0 ;
40787   Dali::Vector2 *arg5 = 0 ;
40788   Dali::Property *argp2 ;
40789   Dali::Property *argp3 ;
40790
40791   arg1 = (Dali::LinearConstrainer *)jarg1;
40792   argp2 = (Dali::Property *)jarg2;
40793   if (!argp2) {
40794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40795     return ;
40796   }
40797   arg2 = *argp2;
40798   argp3 = (Dali::Property *)jarg3;
40799   if (!argp3) {
40800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40801     return ;
40802   }
40803   arg3 = *argp3;
40804   arg4 = (Dali::Vector2 *)jarg4;
40805   if (!arg4) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40807     return ;
40808   }
40809   arg5 = (Dali::Vector2 *)jarg5;
40810   if (!arg5) {
40811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40812     return ;
40813   }
40814   {
40815     try {
40816       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40817     } catch (std::out_of_range& e) {
40818       {
40819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40820       };
40821     } catch (std::exception& e) {
40822       {
40823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40824       };
40825     } catch (...) {
40826       {
40827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40828       };
40829     }
40830   }
40831 }
40832
40833
40834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40835   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40836   SwigValueWrapper< Dali::Property > arg2 ;
40837   SwigValueWrapper< Dali::Property > arg3 ;
40838   Dali::Vector2 *arg4 = 0 ;
40839   Dali::Property *argp2 ;
40840   Dali::Property *argp3 ;
40841
40842   arg1 = (Dali::LinearConstrainer *)jarg1;
40843   argp2 = (Dali::Property *)jarg2;
40844   if (!argp2) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40846     return ;
40847   }
40848   arg2 = *argp2;
40849   argp3 = (Dali::Property *)jarg3;
40850   if (!argp3) {
40851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40852     return ;
40853   }
40854   arg3 = *argp3;
40855   arg4 = (Dali::Vector2 *)jarg4;
40856   if (!arg4) {
40857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40858     return ;
40859   }
40860   {
40861     try {
40862       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (...) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40874       };
40875     }
40876   }
40877 }
40878
40879
40880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40881   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40882   Dali::Handle *arg2 = 0 ;
40883
40884   arg1 = (Dali::LinearConstrainer *)jarg1;
40885   arg2 = (Dali::Handle *)jarg2;
40886   if (!arg2) {
40887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40888     return ;
40889   }
40890   {
40891     try {
40892       (arg1)->Remove(*arg2);
40893     } catch (std::out_of_range& e) {
40894       {
40895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (std::exception& e) {
40898       {
40899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40904       };
40905     }
40906   }
40907 }
40908
40909
40910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40911   int jresult ;
40912   int result;
40913
40914   result = (int)Dali::PathConstrainer::Property::FORWARD;
40915   jresult = (int)result;
40916   return jresult;
40917 }
40918
40919
40920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40921   int jresult ;
40922   int result;
40923
40924   result = (int)Dali::PathConstrainer::Property::POINTS;
40925   jresult = (int)result;
40926   return jresult;
40927 }
40928
40929
40930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40931   int jresult ;
40932   int result;
40933
40934   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40935   jresult = (int)result;
40936   return jresult;
40937 }
40938
40939
40940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40941   void * jresult ;
40942   Dali::PathConstrainer::Property *result = 0 ;
40943
40944   {
40945     try {
40946       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40947     } catch (std::out_of_range& e) {
40948       {
40949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40950       };
40951     } catch (std::exception& e) {
40952       {
40953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (...) {
40956       {
40957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40958       };
40959     }
40960   }
40961   jresult = (void *)result;
40962   return jresult;
40963 }
40964
40965
40966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40967   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40968
40969   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40970   {
40971     try {
40972       delete arg1;
40973     } catch (std::out_of_range& e) {
40974       {
40975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40976       };
40977     } catch (std::exception& e) {
40978       {
40979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (...) {
40982       {
40983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40984       };
40985     }
40986   }
40987 }
40988
40989
40990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40991   void * jresult ;
40992   Dali::PathConstrainer result;
40993
40994   {
40995     try {
40996       result = Dali::PathConstrainer::New();
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41004       };
41005     } catch (...) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41008       };
41009     }
41010   }
41011   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41012   return jresult;
41013 }
41014
41015
41016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
41017   void * jresult ;
41018   Dali::BaseHandle arg1 ;
41019   Dali::BaseHandle *argp1 ;
41020   Dali::PathConstrainer result;
41021
41022   argp1 = (Dali::BaseHandle *)jarg1;
41023   if (!argp1) {
41024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41025     return 0;
41026   }
41027   arg1 = *argp1;
41028   {
41029     try {
41030       result = Dali::PathConstrainer::DownCast(arg1);
41031     } catch (std::out_of_range& e) {
41032       {
41033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (std::exception& e) {
41036       {
41037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
41051   void * jresult ;
41052   Dali::PathConstrainer *result = 0 ;
41053
41054   {
41055     try {
41056       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
41057     } catch (std::out_of_range& e) {
41058       {
41059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41060       };
41061     } catch (std::exception& e) {
41062       {
41063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41064       };
41065     } catch (...) {
41066       {
41067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41068       };
41069     }
41070   }
41071   jresult = (void *)result;
41072   return jresult;
41073 }
41074
41075
41076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
41077   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41078
41079   arg1 = (Dali::PathConstrainer *)jarg1;
41080   {
41081     try {
41082       delete arg1;
41083     } catch (std::out_of_range& e) {
41084       {
41085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41086       };
41087     } catch (std::exception& e) {
41088       {
41089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (...) {
41092       {
41093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41094       };
41095     }
41096   }
41097 }
41098
41099
41100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41101   void * jresult ;
41102   Dali::PathConstrainer *arg1 = 0 ;
41103   Dali::PathConstrainer *result = 0 ;
41104
41105   arg1 = (Dali::PathConstrainer *)jarg1;
41106   if (!arg1) {
41107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41108     return 0;
41109   }
41110   {
41111     try {
41112       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (...) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41124       };
41125     }
41126   }
41127   jresult = (void *)result;
41128   return jresult;
41129 }
41130
41131
41132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41133   void * jresult ;
41134   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41135   Dali::PathConstrainer *arg2 = 0 ;
41136   Dali::PathConstrainer *result = 0 ;
41137
41138   arg1 = (Dali::PathConstrainer *)jarg1;
41139   arg2 = (Dali::PathConstrainer *)jarg2;
41140   if (!arg2) {
41141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41142     return 0;
41143   }
41144   {
41145     try {
41146       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41147     } catch (std::out_of_range& e) {
41148       {
41149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (std::exception& e) {
41152       {
41153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41158       };
41159     }
41160   }
41161   jresult = (void *)result;
41162   return jresult;
41163 }
41164
41165
41166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41167   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41168   SwigValueWrapper< Dali::Property > arg2 ;
41169   SwigValueWrapper< Dali::Property > arg3 ;
41170   Dali::Vector2 *arg4 = 0 ;
41171   Dali::Vector2 *arg5 = 0 ;
41172   Dali::Property *argp2 ;
41173   Dali::Property *argp3 ;
41174
41175   arg1 = (Dali::PathConstrainer *)jarg1;
41176   argp2 = (Dali::Property *)jarg2;
41177   if (!argp2) {
41178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41179     return ;
41180   }
41181   arg2 = *argp2;
41182   argp3 = (Dali::Property *)jarg3;
41183   if (!argp3) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41185     return ;
41186   }
41187   arg3 = *argp3;
41188   arg4 = (Dali::Vector2 *)jarg4;
41189   if (!arg4) {
41190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41191     return ;
41192   }
41193   arg5 = (Dali::Vector2 *)jarg5;
41194   if (!arg5) {
41195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41196     return ;
41197   }
41198   {
41199     try {
41200       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41201     } catch (std::out_of_range& e) {
41202       {
41203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41204       };
41205     } catch (std::exception& e) {
41206       {
41207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41212       };
41213     }
41214   }
41215 }
41216
41217
41218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41219   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41220   SwigValueWrapper< Dali::Property > arg2 ;
41221   SwigValueWrapper< Dali::Property > arg3 ;
41222   Dali::Vector2 *arg4 = 0 ;
41223   Dali::Property *argp2 ;
41224   Dali::Property *argp3 ;
41225
41226   arg1 = (Dali::PathConstrainer *)jarg1;
41227   argp2 = (Dali::Property *)jarg2;
41228   if (!argp2) {
41229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41230     return ;
41231   }
41232   arg2 = *argp2;
41233   argp3 = (Dali::Property *)jarg3;
41234   if (!argp3) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41236     return ;
41237   }
41238   arg3 = *argp3;
41239   arg4 = (Dali::Vector2 *)jarg4;
41240   if (!arg4) {
41241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41242     return ;
41243   }
41244   {
41245     try {
41246       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41247     } catch (std::out_of_range& e) {
41248       {
41249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41250       };
41251     } catch (std::exception& e) {
41252       {
41253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41254       };
41255     } catch (...) {
41256       {
41257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41258       };
41259     }
41260   }
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41265   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41266   Dali::Handle *arg2 = 0 ;
41267
41268   arg1 = (Dali::PathConstrainer *)jarg1;
41269   arg2 = (Dali::Handle *)jarg2;
41270   if (!arg2) {
41271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41272     return ;
41273   }
41274   {
41275     try {
41276       (arg1)->Remove(*arg2);
41277     } catch (std::out_of_range& e) {
41278       {
41279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41280       };
41281     } catch (std::exception& e) {
41282       {
41283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41284       };
41285     } catch (...) {
41286       {
41287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41288       };
41289     }
41290   }
41291 }
41292
41293
41294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41295   int jresult ;
41296   Dali::FittingMode::Type result;
41297
41298   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41299   jresult = (int)result;
41300   return jresult;
41301 }
41302
41303
41304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41305   int jresult ;
41306   Dali::SamplingMode::Type result;
41307
41308   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41309   jresult = (int)result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41315   void * jresult ;
41316   Dali::BufferImage *result = 0 ;
41317
41318   {
41319     try {
41320       result = (Dali::BufferImage *)new Dali::BufferImage();
41321     } catch (std::out_of_range& e) {
41322       {
41323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41324       };
41325     } catch (std::exception& e) {
41326       {
41327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41328       };
41329     } catch (...) {
41330       {
41331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41332       };
41333     }
41334   }
41335   jresult = (void *)result;
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41341   void * jresult ;
41342   unsigned int arg1 ;
41343   unsigned int arg2 ;
41344   Dali::Pixel::Format arg3 ;
41345   Dali::BufferImage result;
41346
41347   arg1 = (unsigned int)jarg1;
41348   arg2 = (unsigned int)jarg2;
41349   arg3 = (Dali::Pixel::Format)jarg3;
41350   {
41351     try {
41352       result = Dali::BufferImage::New(arg1,arg2,arg3);
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (...) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41364       };
41365     }
41366   }
41367   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41373   void * jresult ;
41374   unsigned int arg1 ;
41375   unsigned int arg2 ;
41376   Dali::BufferImage result;
41377
41378   arg1 = (unsigned int)jarg1;
41379   arg2 = (unsigned int)jarg2;
41380   {
41381     try {
41382       result = Dali::BufferImage::New(arg1,arg2);
41383     } catch (std::out_of_range& e) {
41384       {
41385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (std::exception& e) {
41388       {
41389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41403   void * jresult ;
41404   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41405   unsigned int arg2 ;
41406   unsigned int arg3 ;
41407   Dali::Pixel::Format arg4 ;
41408   unsigned int arg5 ;
41409   Dali::BufferImage result;
41410
41411   arg1 = jarg1;
41412   arg2 = (unsigned int)jarg2;
41413   arg3 = (unsigned int)jarg3;
41414   arg4 = (Dali::Pixel::Format)jarg4;
41415   arg5 = (unsigned int)jarg5;
41416   {
41417     try {
41418       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41419     } catch (std::out_of_range& e) {
41420       {
41421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41422       };
41423     } catch (std::exception& e) {
41424       {
41425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (...) {
41428       {
41429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41430       };
41431     }
41432   }
41433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41434
41435
41436   return jresult;
41437 }
41438
41439
41440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41441   void * jresult ;
41442   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41443   unsigned int arg2 ;
41444   unsigned int arg3 ;
41445   Dali::Pixel::Format arg4 ;
41446   Dali::BufferImage result;
41447
41448   arg1 = jarg1;
41449   arg2 = (unsigned int)jarg2;
41450   arg3 = (unsigned int)jarg3;
41451   arg4 = (Dali::Pixel::Format)jarg4;
41452   {
41453     try {
41454       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41455     } catch (std::out_of_range& e) {
41456       {
41457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41458       };
41459     } catch (std::exception& e) {
41460       {
41461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41462       };
41463     } catch (...) {
41464       {
41465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41466       };
41467     }
41468   }
41469   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41470
41471
41472   return jresult;
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41477   void * jresult ;
41478   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41479   unsigned int arg2 ;
41480   unsigned int arg3 ;
41481   Dali::BufferImage result;
41482
41483   arg1 = jarg1;
41484   arg2 = (unsigned int)jarg2;
41485   arg3 = (unsigned int)jarg3;
41486   {
41487     try {
41488       result = Dali::BufferImage::New(arg1,arg2,arg3);
41489     } catch (std::out_of_range& e) {
41490       {
41491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41492       };
41493     } catch (std::exception& e) {
41494       {
41495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41496       };
41497     } catch (...) {
41498       {
41499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41500       };
41501     }
41502   }
41503   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41504
41505
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41511   void * jresult ;
41512   Dali::BaseHandle arg1 ;
41513   Dali::BaseHandle *argp1 ;
41514   Dali::BufferImage result;
41515
41516   argp1 = (Dali::BaseHandle *)jarg1;
41517   if (!argp1) {
41518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41519     return 0;
41520   }
41521   arg1 = *argp1;
41522   {
41523     try {
41524       result = Dali::BufferImage::DownCast(arg1);
41525     } catch (std::out_of_range& e) {
41526       {
41527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (std::exception& e) {
41530       {
41531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41532       };
41533     } catch (...) {
41534       {
41535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41536       };
41537     }
41538   }
41539   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41540   return jresult;
41541 }
41542
41543
41544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41545   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41546
41547   arg1 = (Dali::BufferImage *)jarg1;
41548   {
41549     try {
41550       delete arg1;
41551     } catch (std::out_of_range& e) {
41552       {
41553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41554       };
41555     } catch (std::exception& e) {
41556       {
41557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41562       };
41563     }
41564   }
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41569   void * jresult ;
41570   Dali::BufferImage *arg1 = 0 ;
41571   Dali::BufferImage *result = 0 ;
41572
41573   arg1 = (Dali::BufferImage *)jarg1;
41574   if (!arg1) {
41575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41576     return 0;
41577   }
41578   {
41579     try {
41580       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41581     } catch (std::out_of_range& e) {
41582       {
41583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (std::exception& e) {
41586       {
41587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41588       };
41589     } catch (...) {
41590       {
41591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41592       };
41593     }
41594   }
41595   jresult = (void *)result;
41596   return jresult;
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41601   void * jresult ;
41602   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41603   Dali::BufferImage *arg2 = 0 ;
41604   Dali::BufferImage *result = 0 ;
41605
41606   arg1 = (Dali::BufferImage *)jarg1;
41607   arg2 = (Dali::BufferImage *)jarg2;
41608   if (!arg2) {
41609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41610     return 0;
41611   }
41612   {
41613     try {
41614       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41615     } catch (std::out_of_range& e) {
41616       {
41617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41618       };
41619     } catch (std::exception& e) {
41620       {
41621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41622       };
41623     } catch (...) {
41624       {
41625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41626       };
41627     }
41628   }
41629   jresult = (void *)result;
41630   return jresult;
41631 }
41632
41633
41634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41635   void * jresult ;
41636   Dali::BufferImage result;
41637
41638   {
41639     try {
41640       result = Dali::BufferImage::WHITE();
41641     } catch (std::out_of_range& e) {
41642       {
41643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (std::exception& e) {
41646       {
41647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41652       };
41653     }
41654   }
41655   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41661   void * jresult ;
41662   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41663   Dali::PixelBuffer *result = 0 ;
41664
41665   arg1 = (Dali::BufferImage *)jarg1;
41666   {
41667     try {
41668       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41669     } catch (std::out_of_range& e) {
41670       {
41671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (std::exception& e) {
41674       {
41675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (...) {
41678       {
41679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41680       };
41681     }
41682   }
41683   jresult = (void *)result;
41684   return jresult;
41685 }
41686
41687
41688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41689   unsigned int jresult ;
41690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41691   unsigned int result;
41692
41693   arg1 = (Dali::BufferImage *)jarg1;
41694   {
41695     try {
41696       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41697     } catch (std::out_of_range& e) {
41698       {
41699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (std::exception& e) {
41702       {
41703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41704       };
41705     } catch (...) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41708       };
41709     }
41710   }
41711   jresult = result;
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41717   unsigned int jresult ;
41718   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41719   unsigned int result;
41720
41721   arg1 = (Dali::BufferImage *)jarg1;
41722   {
41723     try {
41724       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (...) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41736       };
41737     }
41738   }
41739   jresult = result;
41740   return jresult;
41741 }
41742
41743
41744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41745   int jresult ;
41746   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41747   Dali::Pixel::Format result;
41748
41749   arg1 = (Dali::BufferImage *)jarg1;
41750   {
41751     try {
41752       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767   jresult = (int)result;
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41773   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41774
41775   arg1 = (Dali::BufferImage *)jarg1;
41776   {
41777     try {
41778       (arg1)->Update();
41779     } catch (std::out_of_range& e) {
41780       {
41781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41782       };
41783     } catch (std::exception& e) {
41784       {
41785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41786       };
41787     } catch (...) {
41788       {
41789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41790       };
41791     }
41792   }
41793 }
41794
41795
41796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41797   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41798   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41799   Dali::RectArea *argp2 ;
41800
41801   arg1 = (Dali::BufferImage *)jarg1;
41802   argp2 = (Dali::RectArea *)jarg2;
41803   if (!argp2) {
41804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41805     return ;
41806   }
41807   arg2 = *argp2;
41808   {
41809     try {
41810       (arg1)->Update(arg2);
41811     } catch (std::out_of_range& e) {
41812       {
41813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41814       };
41815     } catch (std::exception& e) {
41816       {
41817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41818       };
41819     } catch (...) {
41820       {
41821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41822       };
41823     }
41824   }
41825 }
41826
41827
41828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41829   unsigned int jresult ;
41830   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41831   bool result;
41832
41833   arg1 = (Dali::BufferImage *)jarg1;
41834   {
41835     try {
41836       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (...) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41848       };
41849     }
41850   }
41851   jresult = result;
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41857   void * jresult ;
41858   Dali::EncodedBufferImage *result = 0 ;
41859
41860   {
41861     try {
41862       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41863     } catch (std::out_of_range& e) {
41864       {
41865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (std::exception& e) {
41868       {
41869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41883   void * jresult ;
41884   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41885   std::size_t arg2 ;
41886   Dali::EncodedBufferImage result;
41887
41888   arg1 = (uint8_t *)jarg1;
41889   arg2 = (std::size_t)jarg2;
41890   {
41891     try {
41892       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (...) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41904       };
41905     }
41906   }
41907   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41913   void * jresult ;
41914   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41915   std::size_t arg2 ;
41916   Dali::ImageDimensions arg3 ;
41917   Dali::FittingMode::Type arg4 ;
41918   Dali::SamplingMode::Type arg5 ;
41919   bool arg6 ;
41920   Dali::ImageDimensions *argp3 ;
41921   Dali::EncodedBufferImage result;
41922
41923   arg1 = (uint8_t *)jarg1;
41924   arg2 = (std::size_t)jarg2;
41925   argp3 = (Dali::ImageDimensions *)jarg3;
41926   if (!argp3) {
41927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41928     return 0;
41929   }
41930   arg3 = *argp3;
41931   arg4 = (Dali::FittingMode::Type)jarg4;
41932   arg5 = (Dali::SamplingMode::Type)jarg5;
41933   arg6 = jarg6 ? true : false;
41934   {
41935     try {
41936       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41937     } catch (std::out_of_range& e) {
41938       {
41939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (std::exception& e) {
41942       {
41943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (...) {
41946       {
41947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41948       };
41949     }
41950   }
41951   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41952   return jresult;
41953 }
41954
41955
41956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41957   void * jresult ;
41958   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41959   std::size_t arg2 ;
41960   Dali::ImageDimensions arg3 ;
41961   Dali::FittingMode::Type arg4 ;
41962   Dali::SamplingMode::Type arg5 ;
41963   Dali::ImageDimensions *argp3 ;
41964   Dali::EncodedBufferImage result;
41965
41966   arg1 = (uint8_t *)jarg1;
41967   arg2 = (std::size_t)jarg2;
41968   argp3 = (Dali::ImageDimensions *)jarg3;
41969   if (!argp3) {
41970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41971     return 0;
41972   }
41973   arg3 = *argp3;
41974   arg4 = (Dali::FittingMode::Type)jarg4;
41975   arg5 = (Dali::SamplingMode::Type)jarg5;
41976   {
41977     try {
41978       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41979     } catch (std::out_of_range& e) {
41980       {
41981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41982       };
41983     } catch (std::exception& e) {
41984       {
41985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41986       };
41987     } catch (...) {
41988       {
41989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41990       };
41991     }
41992   }
41993   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41994   return jresult;
41995 }
41996
41997
41998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41999   void * jresult ;
42000   Dali::BaseHandle arg1 ;
42001   Dali::BaseHandle *argp1 ;
42002   Dali::EncodedBufferImage result;
42003
42004   argp1 = (Dali::BaseHandle *)jarg1;
42005   if (!argp1) {
42006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42007     return 0;
42008   }
42009   arg1 = *argp1;
42010   {
42011     try {
42012       result = Dali::EncodedBufferImage::DownCast(arg1);
42013     } catch (std::out_of_range& e) {
42014       {
42015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (std::exception& e) {
42018       {
42019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
42033   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42034
42035   arg1 = (Dali::EncodedBufferImage *)jarg1;
42036   {
42037     try {
42038       delete arg1;
42039     } catch (std::out_of_range& e) {
42040       {
42041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42042       };
42043     } catch (std::exception& e) {
42044       {
42045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42046       };
42047     } catch (...) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42050       };
42051     }
42052   }
42053 }
42054
42055
42056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
42057   void * jresult ;
42058   Dali::EncodedBufferImage *arg1 = 0 ;
42059   Dali::EncodedBufferImage *result = 0 ;
42060
42061   arg1 = (Dali::EncodedBufferImage *)jarg1;
42062   if (!arg1) {
42063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42064     return 0;
42065   }
42066   {
42067     try {
42068       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
42069     } catch (std::out_of_range& e) {
42070       {
42071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42072       };
42073     } catch (std::exception& e) {
42074       {
42075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42080       };
42081     }
42082   }
42083   jresult = (void *)result;
42084   return jresult;
42085 }
42086
42087
42088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42089   void * jresult ;
42090   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42091   Dali::EncodedBufferImage *arg2 = 0 ;
42092   Dali::EncodedBufferImage *result = 0 ;
42093
42094   arg1 = (Dali::EncodedBufferImage *)jarg1;
42095   arg2 = (Dali::EncodedBufferImage *)jarg2;
42096   if (!arg2) {
42097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42098     return 0;
42099   }
42100   {
42101     try {
42102       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42103     } catch (std::out_of_range& e) {
42104       {
42105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42106       };
42107     } catch (std::exception& e) {
42108       {
42109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42110       };
42111     } catch (...) {
42112       {
42113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42114       };
42115     }
42116   }
42117   jresult = (void *)result;
42118   return jresult;
42119 }
42120
42121
42122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42123   void * jresult ;
42124   Dali::NativeImage *result = 0 ;
42125
42126   {
42127     try {
42128       result = (Dali::NativeImage *)new Dali::NativeImage();
42129     } catch (std::out_of_range& e) {
42130       {
42131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (std::exception& e) {
42134       {
42135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42136       };
42137     } catch (...) {
42138       {
42139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42140       };
42141     }
42142   }
42143   jresult = (void *)result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42149   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42150
42151   arg1 = (Dali::NativeImage *)jarg1;
42152   {
42153     try {
42154       delete arg1;
42155     } catch (std::out_of_range& e) {
42156       {
42157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42158       };
42159     } catch (std::exception& e) {
42160       {
42161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42162       };
42163     } catch (...) {
42164       {
42165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42166       };
42167     }
42168   }
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42173   void * jresult ;
42174   Dali::NativeImage *arg1 = 0 ;
42175   Dali::NativeImage *result = 0 ;
42176
42177   arg1 = (Dali::NativeImage *)jarg1;
42178   if (!arg1) {
42179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42180     return 0;
42181   }
42182   {
42183     try {
42184       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42185     } catch (std::out_of_range& e) {
42186       {
42187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (std::exception& e) {
42190       {
42191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199   jresult = (void *)result;
42200   return jresult;
42201 }
42202
42203
42204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42205   void * jresult ;
42206   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42207   Dali::NativeImage *arg2 = 0 ;
42208   Dali::NativeImage *result = 0 ;
42209
42210   arg1 = (Dali::NativeImage *)jarg1;
42211   arg2 = (Dali::NativeImage *)jarg2;
42212   if (!arg2) {
42213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42214     return 0;
42215   }
42216   {
42217     try {
42218       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42219     } catch (std::out_of_range& e) {
42220       {
42221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42222       };
42223     } catch (std::exception& e) {
42224       {
42225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42226       };
42227     } catch (...) {
42228       {
42229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42230       };
42231     }
42232   }
42233   jresult = (void *)result;
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42239   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42240
42241   arg1 = (Dali::NativeImage *)jarg1;
42242   {
42243     try {
42244       (arg1)->CreateGlTexture();
42245     } catch (std::out_of_range& e) {
42246       {
42247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42248       };
42249     } catch (std::exception& e) {
42250       {
42251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42252       };
42253     } catch (...) {
42254       {
42255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42256       };
42257     }
42258   }
42259 }
42260
42261
42262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42263   void * jresult ;
42264   NativeImageInterface *arg1 = 0 ;
42265   Dali::NativeImage result;
42266
42267   arg1 = (NativeImageInterface *)jarg1;
42268   if (!arg1) {
42269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42270     return 0;
42271   }
42272   {
42273     try {
42274       result = Dali::NativeImage::New(*arg1);
42275     } catch (std::out_of_range& e) {
42276       {
42277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42278       };
42279     } catch (std::exception& e) {
42280       {
42281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (...) {
42284       {
42285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42286       };
42287     }
42288   }
42289   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42290   return jresult;
42291 }
42292
42293
42294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42295   void * jresult ;
42296   Dali::BaseHandle arg1 ;
42297   Dali::BaseHandle *argp1 ;
42298   Dali::NativeImage result;
42299
42300   argp1 = (Dali::BaseHandle *)jarg1;
42301   if (!argp1) {
42302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42303     return 0;
42304   }
42305   arg1 = *argp1;
42306   {
42307     try {
42308       result = Dali::NativeImage::DownCast(arg1);
42309     } catch (std::out_of_range& e) {
42310       {
42311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42312       };
42313     } catch (std::exception& e) {
42314       {
42315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (...) {
42318       {
42319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42320       };
42321     }
42322   }
42323   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42329   char * jresult ;
42330   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42331   char *result = 0 ;
42332
42333   arg1 = (Dali::NativeImage *)jarg1;
42334   {
42335     try {
42336       result = (char *)(arg1)->GetCustomFragmentPreFix();
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (...) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42348       };
42349     }
42350   }
42351   jresult = SWIG_csharp_string_callback((const char *)result);
42352   return jresult;
42353 }
42354
42355
42356 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42357   char * jresult ;
42358   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42359   char *result = 0 ;
42360
42361   arg1 = (Dali::NativeImage *)jarg1;
42362   {
42363     try {
42364       result = (char *)(arg1)->GetCustomSamplerTypename();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = SWIG_csharp_string_callback((const char *)result);
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42385   unsigned int jresult ;
42386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42387   bool result;
42388
42389   arg1 = (Dali::NativeImageInterface *)jarg1;
42390   {
42391     try {
42392       result = (bool)(arg1)->GlExtensionCreate();
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42404       };
42405     }
42406   }
42407   jresult = result;
42408   return jresult;
42409 }
42410
42411
42412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42413   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42414
42415   arg1 = (Dali::NativeImageInterface *)jarg1;
42416   {
42417     try {
42418       (arg1)->GlExtensionDestroy();
42419     } catch (std::out_of_range& e) {
42420       {
42421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42422       };
42423     } catch (std::exception& e) {
42424       {
42425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42430       };
42431     }
42432   }
42433 }
42434
42435
42436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42437   unsigned int jresult ;
42438   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42439   unsigned int result;
42440
42441   arg1 = (Dali::NativeImageInterface *)jarg1;
42442   {
42443     try {
42444       result = (unsigned int)(arg1)->TargetTexture();
42445     } catch (std::out_of_range& e) {
42446       {
42447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (std::exception& e) {
42450       {
42451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (...) {
42454       {
42455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42456       };
42457     }
42458   }
42459   jresult = result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42466
42467   arg1 = (Dali::NativeImageInterface *)jarg1;
42468   {
42469     try {
42470       (arg1)->PrepareTexture();
42471     } catch (std::out_of_range& e) {
42472       {
42473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42474       };
42475     } catch (std::exception& e) {
42476       {
42477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (...) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42482       };
42483     }
42484   }
42485 }
42486
42487
42488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42489   unsigned int jresult ;
42490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42491   unsigned int result;
42492
42493   arg1 = (Dali::NativeImageInterface *)jarg1;
42494   {
42495     try {
42496       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42497     } catch (std::out_of_range& e) {
42498       {
42499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (std::exception& e) {
42502       {
42503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42508       };
42509     }
42510   }
42511   jresult = result;
42512   return jresult;
42513 }
42514
42515
42516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42517   unsigned int jresult ;
42518   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42519   unsigned int result;
42520
42521   arg1 = (Dali::NativeImageInterface *)jarg1;
42522   {
42523     try {
42524       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42525     } catch (std::out_of_range& e) {
42526       {
42527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (std::exception& e) {
42530       {
42531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42532       };
42533     } catch (...) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42536       };
42537     }
42538   }
42539   jresult = result;
42540   return jresult;
42541 }
42542
42543
42544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42545   unsigned int jresult ;
42546   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42547   bool result;
42548
42549   arg1 = (Dali::NativeImageInterface *)jarg1;
42550   {
42551     try {
42552       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42553     } catch (std::out_of_range& e) {
42554       {
42555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42556       };
42557     } catch (std::exception& e) {
42558       {
42559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42560       };
42561     } catch (...) {
42562       {
42563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42564       };
42565     }
42566   }
42567   jresult = result;
42568   return jresult;
42569 }
42570
42571
42572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42573   void * jresult ;
42574   std::string *arg1 = 0 ;
42575   Dali::ImageDimensions result;
42576
42577   if (!jarg1) {
42578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42579     return 0;
42580   }
42581   std::string arg1_str(jarg1);
42582   arg1 = &arg1_str;
42583   {
42584     try {
42585       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42586     } catch (std::out_of_range& e) {
42587       {
42588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (std::exception& e) {
42591       {
42592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42601
42602   //argout typemap for const std::string&
42603
42604   return jresult;
42605 }
42606
42607
42608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42609   void * jresult ;
42610   Dali::ResourceImage *result = 0 ;
42611
42612   {
42613     try {
42614       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (...) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42626       };
42627     }
42628   }
42629   jresult = (void *)result;
42630   return jresult;
42631 }
42632
42633
42634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42635   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42636
42637   arg1 = (Dali::ResourceImage *)jarg1;
42638   {
42639     try {
42640       delete arg1;
42641     } catch (std::out_of_range& e) {
42642       {
42643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42644       };
42645     } catch (std::exception& e) {
42646       {
42647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42648       };
42649     } catch (...) {
42650       {
42651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42652       };
42653     }
42654   }
42655 }
42656
42657
42658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42659   void * jresult ;
42660   Dali::ResourceImage *arg1 = 0 ;
42661   Dali::ResourceImage *result = 0 ;
42662
42663   arg1 = (Dali::ResourceImage *)jarg1;
42664   if (!arg1) {
42665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42666     return 0;
42667   }
42668   {
42669     try {
42670       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42671     } catch (std::out_of_range& e) {
42672       {
42673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (std::exception& e) {
42676       {
42677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42691   void * jresult ;
42692   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42693   Dali::ResourceImage *arg2 = 0 ;
42694   Dali::ResourceImage *result = 0 ;
42695
42696   arg1 = (Dali::ResourceImage *)jarg1;
42697   arg2 = (Dali::ResourceImage *)jarg2;
42698   if (!arg2) {
42699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42700     return 0;
42701   }
42702   {
42703     try {
42704       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42705     } catch (std::out_of_range& e) {
42706       {
42707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42708       };
42709     } catch (std::exception& e) {
42710       {
42711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42712       };
42713     } catch (...) {
42714       {
42715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42716       };
42717     }
42718   }
42719   jresult = (void *)result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42725   void * jresult ;
42726   std::string *arg1 = 0 ;
42727   bool arg2 ;
42728   Dali::ResourceImage result;
42729
42730   if (!jarg1) {
42731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42732     return 0;
42733   }
42734   std::string arg1_str(jarg1);
42735   arg1 = &arg1_str;
42736   arg2 = jarg2 ? true : false;
42737   {
42738     try {
42739       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42755
42756   //argout typemap for const std::string&
42757
42758   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42763   void * jresult ;
42764   std::string *arg1 = 0 ;
42765   Dali::ResourceImage result;
42766
42767   if (!jarg1) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42769     return 0;
42770   }
42771   std::string arg1_str(jarg1);
42772   arg1 = &arg1_str;
42773   {
42774     try {
42775       result = Dali::ResourceImage::New((std::string const &)*arg1);
42776     } catch (std::out_of_range& e) {
42777       {
42778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42779       };
42780     } catch (std::exception& e) {
42781       {
42782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (...) {
42785       {
42786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42787       };
42788     }
42789   }
42790   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42791
42792   //argout typemap for const std::string&
42793
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42799   void * jresult ;
42800   std::string *arg1 = 0 ;
42801   Dali::ImageDimensions arg2 ;
42802   Dali::FittingMode::Type arg3 ;
42803   Dali::SamplingMode::Type arg4 ;
42804   bool arg5 ;
42805   Dali::ImageDimensions *argp2 ;
42806   Dali::ResourceImage result;
42807
42808   if (!jarg1) {
42809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42810     return 0;
42811   }
42812   std::string arg1_str(jarg1);
42813   arg1 = &arg1_str;
42814   argp2 = (Dali::ImageDimensions *)jarg2;
42815   if (!argp2) {
42816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42817     return 0;
42818   }
42819   arg2 = *argp2;
42820   arg3 = (Dali::FittingMode::Type)jarg3;
42821   arg4 = (Dali::SamplingMode::Type)jarg4;
42822   arg5 = jarg5 ? true : false;
42823   {
42824     try {
42825       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42837       };
42838     }
42839   }
42840   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42841
42842   //argout typemap for const std::string&
42843
42844   return jresult;
42845 }
42846
42847
42848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42849   void * jresult ;
42850   std::string *arg1 = 0 ;
42851   Dali::ImageDimensions arg2 ;
42852   Dali::FittingMode::Type arg3 ;
42853   Dali::SamplingMode::Type arg4 ;
42854   Dali::ImageDimensions *argp2 ;
42855   Dali::ResourceImage result;
42856
42857   if (!jarg1) {
42858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42859     return 0;
42860   }
42861   std::string arg1_str(jarg1);
42862   arg1 = &arg1_str;
42863   argp2 = (Dali::ImageDimensions *)jarg2;
42864   if (!argp2) {
42865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42866     return 0;
42867   }
42868   arg2 = *argp2;
42869   arg3 = (Dali::FittingMode::Type)jarg3;
42870   arg4 = (Dali::SamplingMode::Type)jarg4;
42871   {
42872     try {
42873       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42874     } catch (std::out_of_range& e) {
42875       {
42876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42877       };
42878     } catch (std::exception& e) {
42879       {
42880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (...) {
42883       {
42884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42885       };
42886     }
42887   }
42888   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42889
42890   //argout typemap for const std::string&
42891
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42897   void * jresult ;
42898   std::string *arg1 = 0 ;
42899   Dali::ImageDimensions arg2 ;
42900   Dali::FittingMode::Type arg3 ;
42901   Dali::ImageDimensions *argp2 ;
42902   Dali::ResourceImage result;
42903
42904   if (!jarg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42906     return 0;
42907   }
42908   std::string arg1_str(jarg1);
42909   arg1 = &arg1_str;
42910   argp2 = (Dali::ImageDimensions *)jarg2;
42911   if (!argp2) {
42912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42913     return 0;
42914   }
42915   arg2 = *argp2;
42916   arg3 = (Dali::FittingMode::Type)jarg3;
42917   {
42918     try {
42919       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42935
42936   //argout typemap for const std::string&
42937
42938   return jresult;
42939 }
42940
42941
42942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42943   void * jresult ;
42944   std::string *arg1 = 0 ;
42945   Dali::ImageDimensions arg2 ;
42946   Dali::ImageDimensions *argp2 ;
42947   Dali::ResourceImage result;
42948
42949   if (!jarg1) {
42950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42951     return 0;
42952   }
42953   std::string arg1_str(jarg1);
42954   arg1 = &arg1_str;
42955   argp2 = (Dali::ImageDimensions *)jarg2;
42956   if (!argp2) {
42957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42958     return 0;
42959   }
42960   arg2 = *argp2;
42961   {
42962     try {
42963       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (...) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42975       };
42976     }
42977   }
42978   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42979
42980   //argout typemap for const std::string&
42981
42982   return jresult;
42983 }
42984
42985
42986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42987   void * jresult ;
42988   Dali::BaseHandle arg1 ;
42989   Dali::BaseHandle *argp1 ;
42990   Dali::ResourceImage result;
42991
42992   argp1 = (Dali::BaseHandle *)jarg1;
42993   if (!argp1) {
42994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42995     return 0;
42996   }
42997   arg1 = *argp1;
42998   {
42999     try {
43000       result = Dali::ResourceImage::DownCast(arg1);
43001     } catch (std::out_of_range& e) {
43002       {
43003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (std::exception& e) {
43006       {
43007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (...) {
43010       {
43011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43012       };
43013     }
43014   }
43015   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
43021   int jresult ;
43022   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43023   Dali::LoadingState result;
43024
43025   arg1 = (Dali::ResourceImage *)jarg1;
43026   {
43027     try {
43028       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (int)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
43049   char * jresult ;
43050   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43051   std::string result;
43052
43053   arg1 = (Dali::ResourceImage *)jarg1;
43054   {
43055     try {
43056       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43068       };
43069     }
43070   }
43071   jresult = SWIG_csharp_string_callback((&result)->c_str());
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
43077   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43078
43079   arg1 = (Dali::ResourceImage *)jarg1;
43080   {
43081     try {
43082       (arg1)->Reload();
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43094       };
43095     }
43096   }
43097 }
43098
43099
43100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43101   void * jresult ;
43102   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43103   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43104
43105   arg1 = (Dali::ResourceImage *)jarg1;
43106   {
43107     try {
43108       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43109     } catch (std::out_of_range& e) {
43110       {
43111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (std::exception& e) {
43114       {
43115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43120       };
43121     }
43122   }
43123   jresult = (void *)result;
43124   return jresult;
43125 }
43126
43127
43128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43129   void * jresult ;
43130   Dali::FrameBufferImage *result = 0 ;
43131
43132   {
43133     try {
43134       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43135     } catch (std::out_of_range& e) {
43136       {
43137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43138       };
43139     } catch (std::exception& e) {
43140       {
43141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43142       };
43143     } catch (...) {
43144       {
43145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43146       };
43147     }
43148   }
43149   jresult = (void *)result;
43150   return jresult;
43151 }
43152
43153
43154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43155   void * jresult ;
43156   unsigned int arg1 ;
43157   unsigned int arg2 ;
43158   Dali::Pixel::Format arg3 ;
43159   Dali::RenderBuffer::Format arg4 ;
43160   Dali::FrameBufferImage result;
43161
43162   arg1 = (unsigned int)jarg1;
43163   arg2 = (unsigned int)jarg2;
43164   arg3 = (Dali::Pixel::Format)jarg3;
43165   arg4 = (Dali::RenderBuffer::Format)jarg4;
43166   {
43167     try {
43168       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43169     } catch (std::out_of_range& e) {
43170       {
43171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43172       };
43173     } catch (std::exception& e) {
43174       {
43175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43176       };
43177     } catch (...) {
43178       {
43179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43180       };
43181     }
43182   }
43183   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43184   return jresult;
43185 }
43186
43187
43188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43189   void * jresult ;
43190   unsigned int arg1 ;
43191   unsigned int arg2 ;
43192   Dali::Pixel::Format arg3 ;
43193   Dali::FrameBufferImage result;
43194
43195   arg1 = (unsigned int)jarg1;
43196   arg2 = (unsigned int)jarg2;
43197   arg3 = (Dali::Pixel::Format)jarg3;
43198   {
43199     try {
43200       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43201     } catch (std::out_of_range& e) {
43202       {
43203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (std::exception& e) {
43206       {
43207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43221   void * jresult ;
43222   unsigned int arg1 ;
43223   unsigned int arg2 ;
43224   Dali::FrameBufferImage result;
43225
43226   arg1 = (unsigned int)jarg1;
43227   arg2 = (unsigned int)jarg2;
43228   {
43229     try {
43230       result = Dali::FrameBufferImage::New(arg1,arg2);
43231     } catch (std::out_of_range& e) {
43232       {
43233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43234       };
43235     } catch (std::exception& e) {
43236       {
43237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43238       };
43239     } catch (...) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43242       };
43243     }
43244   }
43245   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43246   return jresult;
43247 }
43248
43249
43250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43251   void * jresult ;
43252   unsigned int arg1 ;
43253   Dali::FrameBufferImage result;
43254
43255   arg1 = (unsigned int)jarg1;
43256   {
43257     try {
43258       result = Dali::FrameBufferImage::New(arg1);
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43266       };
43267     } catch (...) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43270       };
43271     }
43272   }
43273   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43274   return jresult;
43275 }
43276
43277
43278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43279   void * jresult ;
43280   Dali::FrameBufferImage result;
43281
43282   {
43283     try {
43284       result = Dali::FrameBufferImage::New();
43285     } catch (std::out_of_range& e) {
43286       {
43287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43288       };
43289     } catch (std::exception& e) {
43290       {
43291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43292       };
43293     } catch (...) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43296       };
43297     }
43298   }
43299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43300   return jresult;
43301 }
43302
43303
43304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43305   void * jresult ;
43306   Dali::NativeImageInterface *arg1 = 0 ;
43307   Dali::FrameBufferImage result;
43308
43309   arg1 = (Dali::NativeImageInterface *)jarg1;
43310   if (!arg1) {
43311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43312     return 0;
43313   }
43314   {
43315     try {
43316       result = Dali::FrameBufferImage::New(*arg1);
43317     } catch (std::out_of_range& e) {
43318       {
43319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43320       };
43321     } catch (std::exception& e) {
43322       {
43323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43328       };
43329     }
43330   }
43331   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43337   void * jresult ;
43338   Dali::BaseHandle arg1 ;
43339   Dali::BaseHandle *argp1 ;
43340   Dali::FrameBufferImage result;
43341
43342   argp1 = (Dali::BaseHandle *)jarg1;
43343   if (!argp1) {
43344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43345     return 0;
43346   }
43347   arg1 = *argp1;
43348   {
43349     try {
43350       result = Dali::FrameBufferImage::DownCast(arg1);
43351     } catch (std::out_of_range& e) {
43352       {
43353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (std::exception& e) {
43356       {
43357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43371   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43372
43373   arg1 = (Dali::FrameBufferImage *)jarg1;
43374   {
43375     try {
43376       delete arg1;
43377     } catch (std::out_of_range& e) {
43378       {
43379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43380       };
43381     } catch (std::exception& e) {
43382       {
43383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43384       };
43385     } catch (...) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43388       };
43389     }
43390   }
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43395   void * jresult ;
43396   Dali::FrameBufferImage *arg1 = 0 ;
43397   Dali::FrameBufferImage *result = 0 ;
43398
43399   arg1 = (Dali::FrameBufferImage *)jarg1;
43400   if (!arg1) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43402     return 0;
43403   }
43404   {
43405     try {
43406       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43427   void * jresult ;
43428   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43429   Dali::FrameBufferImage *arg2 = 0 ;
43430   Dali::FrameBufferImage *result = 0 ;
43431
43432   arg1 = (Dali::FrameBufferImage *)jarg1;
43433   arg2 = (Dali::FrameBufferImage *)jarg2;
43434   if (!arg2) {
43435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43436     return 0;
43437   }
43438   {
43439     try {
43440       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43441     } catch (std::out_of_range& e) {
43442       {
43443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (std::exception& e) {
43446       {
43447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43448       };
43449     } catch (...) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43452       };
43453     }
43454   }
43455   jresult = (void *)result;
43456   return jresult;
43457 }
43458
43459
43460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43461   void * jresult ;
43462   Dali::NinePatchImage *result = 0 ;
43463
43464   {
43465     try {
43466       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43467     } catch (std::out_of_range& e) {
43468       {
43469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (std::exception& e) {
43472       {
43473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (...) {
43476       {
43477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43478       };
43479     }
43480   }
43481   jresult = (void *)result;
43482   return jresult;
43483 }
43484
43485
43486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43487   void * jresult ;
43488   std::string *arg1 = 0 ;
43489   Dali::NinePatchImage result;
43490
43491   if (!jarg1) {
43492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43493     return 0;
43494   }
43495   std::string arg1_str(jarg1);
43496   arg1 = &arg1_str;
43497   {
43498     try {
43499       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (...) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43511       };
43512     }
43513   }
43514   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43515
43516   //argout typemap for const std::string&
43517
43518   return jresult;
43519 }
43520
43521
43522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43523   void * jresult ;
43524   Dali::BaseHandle arg1 ;
43525   Dali::BaseHandle *argp1 ;
43526   Dali::NinePatchImage result;
43527
43528   argp1 = (Dali::BaseHandle *)jarg1;
43529   if (!argp1) {
43530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43531     return 0;
43532   }
43533   arg1 = *argp1;
43534   {
43535     try {
43536       result = Dali::NinePatchImage::DownCast(arg1);
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43548       };
43549     }
43550   }
43551   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43552   return jresult;
43553 }
43554
43555
43556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43557   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43558
43559   arg1 = (Dali::NinePatchImage *)jarg1;
43560   {
43561     try {
43562       delete arg1;
43563     } catch (std::out_of_range& e) {
43564       {
43565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43566       };
43567     } catch (std::exception& e) {
43568       {
43569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43570       };
43571     } catch (...) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43574       };
43575     }
43576   }
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43581   void * jresult ;
43582   Dali::NinePatchImage *arg1 = 0 ;
43583   Dali::NinePatchImage *result = 0 ;
43584
43585   arg1 = (Dali::NinePatchImage *)jarg1;
43586   if (!arg1) {
43587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43588     return 0;
43589   }
43590   {
43591     try {
43592       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607   jresult = (void *)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43613   void * jresult ;
43614   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43615   Dali::NinePatchImage *arg2 = 0 ;
43616   Dali::NinePatchImage *result = 0 ;
43617
43618   arg1 = (Dali::NinePatchImage *)jarg1;
43619   arg2 = (Dali::NinePatchImage *)jarg2;
43620   if (!arg2) {
43621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43622     return 0;
43623   }
43624   {
43625     try {
43626       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43627     } catch (std::out_of_range& e) {
43628       {
43629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (std::exception& e) {
43632       {
43633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43647   void * jresult ;
43648   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43649   Dali::Vector4 result;
43650
43651   arg1 = (Dali::NinePatchImage *)jarg1;
43652   {
43653     try {
43654       result = (arg1)->GetStretchBorders();
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43666       };
43667     }
43668   }
43669   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43675   void * jresult ;
43676   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43677   Dali::NinePatchImage::StretchRanges *result = 0 ;
43678
43679   arg1 = (Dali::NinePatchImage *)jarg1;
43680   {
43681     try {
43682       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43683     } catch (std::out_of_range& e) {
43684       {
43685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (std::exception& e) {
43688       {
43689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697   jresult = (void *)result;
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43703   void * jresult ;
43704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43705   Dali::NinePatchImage::StretchRanges *result = 0 ;
43706
43707   arg1 = (Dali::NinePatchImage *)jarg1;
43708   {
43709     try {
43710       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43711     } catch (std::out_of_range& e) {
43712       {
43713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43714       };
43715     } catch (std::exception& e) {
43716       {
43717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (...) {
43720       {
43721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43722       };
43723     }
43724   }
43725   jresult = (void *)result;
43726   return jresult;
43727 }
43728
43729
43730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43731   void * jresult ;
43732   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43733   Dali::Rect< int > result;
43734
43735   arg1 = (Dali::NinePatchImage *)jarg1;
43736   {
43737     try {
43738       result = (arg1)->GetChildRectangle();
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (...) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43750       };
43751     }
43752   }
43753   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43759   void * jresult ;
43760   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43761   Dali::BufferImage result;
43762
43763   arg1 = (Dali::NinePatchImage *)jarg1;
43764   {
43765     try {
43766       result = (arg1)->CreateCroppedBufferImage();
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43774       };
43775     } catch (...) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43778       };
43779     }
43780   }
43781   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43782   return jresult;
43783 }
43784
43785
43786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43787   unsigned int jresult ;
43788   std::string *arg1 = 0 ;
43789   bool result;
43790
43791   if (!jarg1) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43793     return 0;
43794   }
43795   std::string arg1_str(jarg1);
43796   arg1 = &arg1_str;
43797   {
43798     try {
43799       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43800     } catch (std::out_of_range& e) {
43801       {
43802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43803       };
43804     } catch (std::exception& e) {
43805       {
43806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (...) {
43809       {
43810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43811       };
43812     }
43813   }
43814   jresult = result;
43815
43816   //argout typemap for const std::string&
43817
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43823   int jresult ;
43824   int result;
43825
43826   result = (int)Dali::CameraActor::Property::TYPE;
43827   jresult = (int)result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43833   int jresult ;
43834   int result;
43835
43836   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43837   jresult = (int)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43843   int jresult ;
43844   int result;
43845
43846   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43847   jresult = (int)result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43853   int jresult ;
43854   int result;
43855
43856   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43857   jresult = (int)result;
43858   return jresult;
43859 }
43860
43861
43862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43863   int jresult ;
43864   int result;
43865
43866   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43867   jresult = (int)result;
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43873   int jresult ;
43874   int result;
43875
43876   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43877   jresult = (int)result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43883   int jresult ;
43884   int result;
43885
43886   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43887   jresult = (int)result;
43888   return jresult;
43889 }
43890
43891
43892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43893   int jresult ;
43894   int result;
43895
43896   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43897   jresult = (int)result;
43898   return jresult;
43899 }
43900
43901
43902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43903   int jresult ;
43904   int result;
43905
43906   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43907   jresult = (int)result;
43908   return jresult;
43909 }
43910
43911
43912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43913   int jresult ;
43914   int result;
43915
43916   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43917   jresult = (int)result;
43918   return jresult;
43919 }
43920
43921
43922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43923   int jresult ;
43924   int result;
43925
43926   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43927   jresult = (int)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43933   int jresult ;
43934   int result;
43935
43936   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43937   jresult = (int)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43943   int jresult ;
43944   int result;
43945
43946   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43947   jresult = (int)result;
43948   return jresult;
43949 }
43950
43951
43952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43953   int jresult ;
43954   int result;
43955
43956   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43957   jresult = (int)result;
43958   return jresult;
43959 }
43960
43961
43962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43963   void * jresult ;
43964   Dali::CameraActor::Property *result = 0 ;
43965
43966   {
43967     try {
43968       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43969     } catch (std::out_of_range& e) {
43970       {
43971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43972       };
43973     } catch (std::exception& e) {
43974       {
43975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43976       };
43977     } catch (...) {
43978       {
43979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43980       };
43981     }
43982   }
43983   jresult = (void *)result;
43984   return jresult;
43985 }
43986
43987
43988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43989   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43990
43991   arg1 = (Dali::CameraActor::Property *)jarg1;
43992   {
43993     try {
43994       delete arg1;
43995     } catch (std::out_of_range& e) {
43996       {
43997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43998       };
43999     } catch (std::exception& e) {
44000       {
44001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44002       };
44003     } catch (...) {
44004       {
44005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44006       };
44007     }
44008   }
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44013   void * jresult ;
44014   Dali::CameraActor *result = 0 ;
44015
44016   {
44017     try {
44018       result = (Dali::CameraActor *)new Dali::CameraActor();
44019     } catch (std::out_of_range& e) {
44020       {
44021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (std::exception& e) {
44024       {
44025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033   jresult = (void *)result;
44034   return jresult;
44035 }
44036
44037
44038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44039   void * jresult ;
44040   Dali::CameraActor result;
44041
44042   {
44043     try {
44044       result = Dali::CameraActor::New();
44045     } catch (std::out_of_range& e) {
44046       {
44047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44048       };
44049     } catch (std::exception& e) {
44050       {
44051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44056       };
44057     }
44058   }
44059   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44060   return jresult;
44061 }
44062
44063
44064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44065   void * jresult ;
44066   Dali::Size *arg1 = 0 ;
44067   Dali::CameraActor result;
44068
44069   arg1 = (Dali::Size *)jarg1;
44070   if (!arg1) {
44071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44072     return 0;
44073   }
44074   {
44075     try {
44076       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44077     } catch (std::out_of_range& e) {
44078       {
44079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44080       };
44081     } catch (std::exception& e) {
44082       {
44083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44084       };
44085     } catch (...) {
44086       {
44087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44088       };
44089     }
44090   }
44091   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44092   return jresult;
44093 }
44094
44095
44096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44097   void * jresult ;
44098   Dali::BaseHandle arg1 ;
44099   Dali::BaseHandle *argp1 ;
44100   Dali::CameraActor result;
44101
44102   argp1 = (Dali::BaseHandle *)jarg1;
44103   if (!argp1) {
44104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44105     return 0;
44106   }
44107   arg1 = *argp1;
44108   {
44109     try {
44110       result = Dali::CameraActor::DownCast(arg1);
44111     } catch (std::out_of_range& e) {
44112       {
44113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44114       };
44115     } catch (std::exception& e) {
44116       {
44117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44118       };
44119     } catch (...) {
44120       {
44121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44122       };
44123     }
44124   }
44125   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44126   return jresult;
44127 }
44128
44129
44130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44131   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44132
44133   arg1 = (Dali::CameraActor *)jarg1;
44134   {
44135     try {
44136       delete arg1;
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44148       };
44149     }
44150   }
44151 }
44152
44153
44154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44155   void * jresult ;
44156   Dali::CameraActor *arg1 = 0 ;
44157   Dali::CameraActor *result = 0 ;
44158
44159   arg1 = (Dali::CameraActor *)jarg1;
44160   if (!arg1) {
44161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44162     return 0;
44163   }
44164   {
44165     try {
44166       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44167     } catch (std::out_of_range& e) {
44168       {
44169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44170       };
44171     } catch (std::exception& e) {
44172       {
44173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (...) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44178       };
44179     }
44180   }
44181   jresult = (void *)result;
44182   return jresult;
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44187   void * jresult ;
44188   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44189   Dali::CameraActor *arg2 = 0 ;
44190   Dali::CameraActor *result = 0 ;
44191
44192   arg1 = (Dali::CameraActor *)jarg1;
44193   arg2 = (Dali::CameraActor *)jarg2;
44194   if (!arg2) {
44195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44196     return 0;
44197   }
44198   {
44199     try {
44200       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44201     } catch (std::out_of_range& e) {
44202       {
44203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44204       };
44205     } catch (std::exception& e) {
44206       {
44207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44208       };
44209     } catch (...) {
44210       {
44211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44212       };
44213     }
44214   }
44215   jresult = (void *)result;
44216   return jresult;
44217 }
44218
44219
44220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44221   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44222   Dali::Camera::Type arg2 ;
44223
44224   arg1 = (Dali::CameraActor *)jarg1;
44225   arg2 = (Dali::Camera::Type)jarg2;
44226   {
44227     try {
44228       (arg1)->SetType(arg2);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44240       };
44241     }
44242   }
44243 }
44244
44245
44246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44247   int jresult ;
44248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44249   Dali::Camera::Type result;
44250
44251   arg1 = (Dali::CameraActor *)jarg1;
44252   {
44253     try {
44254       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44255     } catch (std::out_of_range& e) {
44256       {
44257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44258       };
44259     } catch (std::exception& e) {
44260       {
44261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44262       };
44263     } catch (...) {
44264       {
44265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44266       };
44267     }
44268   }
44269   jresult = (int)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44275   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44276   Dali::Camera::ProjectionMode arg2 ;
44277
44278   arg1 = (Dali::CameraActor *)jarg1;
44279   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44280   {
44281     try {
44282       (arg1)->SetProjectionMode(arg2);
44283     } catch (std::out_of_range& e) {
44284       {
44285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44286       };
44287     } catch (std::exception& e) {
44288       {
44289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (...) {
44292       {
44293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44294       };
44295     }
44296   }
44297 }
44298
44299
44300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44301   int jresult ;
44302   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44303   Dali::Camera::ProjectionMode result;
44304
44305   arg1 = (Dali::CameraActor *)jarg1;
44306   {
44307     try {
44308       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44309     } catch (std::out_of_range& e) {
44310       {
44311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44312       };
44313     } catch (std::exception& e) {
44314       {
44315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44316       };
44317     } catch (...) {
44318       {
44319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44320       };
44321     }
44322   }
44323   jresult = (int)result;
44324   return jresult;
44325 }
44326
44327
44328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44330   float arg2 ;
44331
44332   arg1 = (Dali::CameraActor *)jarg1;
44333   arg2 = (float)jarg2;
44334   {
44335     try {
44336       (arg1)->SetFieldOfView(arg2);
44337     } catch (std::out_of_range& e) {
44338       {
44339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44340       };
44341     } catch (std::exception& e) {
44342       {
44343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44344       };
44345     } catch (...) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44348       };
44349     }
44350   }
44351 }
44352
44353
44354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44355   float jresult ;
44356   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44357   float result;
44358
44359   arg1 = (Dali::CameraActor *)jarg1;
44360   {
44361     try {
44362       result = (float)(arg1)->GetFieldOfView();
44363     } catch (std::out_of_range& e) {
44364       {
44365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (std::exception& e) {
44368       {
44369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44370       };
44371     } catch (...) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44374       };
44375     }
44376   }
44377   jresult = result;
44378   return jresult;
44379 }
44380
44381
44382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44384   float arg2 ;
44385
44386   arg1 = (Dali::CameraActor *)jarg1;
44387   arg2 = (float)jarg2;
44388   {
44389     try {
44390       (arg1)->SetAspectRatio(arg2);
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44398       };
44399     } catch (...) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44402       };
44403     }
44404   }
44405 }
44406
44407
44408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44409   float jresult ;
44410   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44411   float result;
44412
44413   arg1 = (Dali::CameraActor *)jarg1;
44414   {
44415     try {
44416       result = (float)(arg1)->GetAspectRatio();
44417     } catch (std::out_of_range& e) {
44418       {
44419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44420       };
44421     } catch (std::exception& e) {
44422       {
44423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44424       };
44425     } catch (...) {
44426       {
44427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44428       };
44429     }
44430   }
44431   jresult = result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44437   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44438   float arg2 ;
44439
44440   arg1 = (Dali::CameraActor *)jarg1;
44441   arg2 = (float)jarg2;
44442   {
44443     try {
44444       (arg1)->SetNearClippingPlane(arg2);
44445     } catch (std::out_of_range& e) {
44446       {
44447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44448       };
44449     } catch (std::exception& e) {
44450       {
44451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44452       };
44453     } catch (...) {
44454       {
44455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44456       };
44457     }
44458   }
44459 }
44460
44461
44462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44463   float jresult ;
44464   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44465   float result;
44466
44467   arg1 = (Dali::CameraActor *)jarg1;
44468   {
44469     try {
44470       result = (float)(arg1)->GetNearClippingPlane();
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44478       };
44479     } catch (...) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44482       };
44483     }
44484   }
44485   jresult = result;
44486   return jresult;
44487 }
44488
44489
44490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44491   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44492   float arg2 ;
44493
44494   arg1 = (Dali::CameraActor *)jarg1;
44495   arg2 = (float)jarg2;
44496   {
44497     try {
44498       (arg1)->SetFarClippingPlane(arg2);
44499     } catch (std::out_of_range& e) {
44500       {
44501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44502       };
44503     } catch (std::exception& e) {
44504       {
44505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44506       };
44507     } catch (...) {
44508       {
44509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44510       };
44511     }
44512   }
44513 }
44514
44515
44516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44517   float jresult ;
44518   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44519   float result;
44520
44521   arg1 = (Dali::CameraActor *)jarg1;
44522   {
44523     try {
44524       result = (float)(arg1)->GetFarClippingPlane();
44525     } catch (std::out_of_range& e) {
44526       {
44527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44528       };
44529     } catch (std::exception& e) {
44530       {
44531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44536       };
44537     }
44538   }
44539   jresult = result;
44540   return jresult;
44541 }
44542
44543
44544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44545   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44546   Dali::Vector3 *arg2 = 0 ;
44547
44548   arg1 = (Dali::CameraActor *)jarg1;
44549   arg2 = (Dali::Vector3 *)jarg2;
44550   if (!arg2) {
44551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44552     return ;
44553   }
44554   {
44555     try {
44556       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44557     } catch (std::out_of_range& e) {
44558       {
44559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (std::exception& e) {
44562       {
44563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44568       };
44569     }
44570   }
44571 }
44572
44573
44574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44575   void * jresult ;
44576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44577   Dali::Vector3 result;
44578
44579   arg1 = (Dali::CameraActor *)jarg1;
44580   {
44581     try {
44582       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44583     } catch (std::out_of_range& e) {
44584       {
44585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (std::exception& e) {
44588       {
44589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44590       };
44591     } catch (...) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44594       };
44595     }
44596   }
44597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44598   return jresult;
44599 }
44600
44601
44602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44604   bool arg2 ;
44605
44606   arg1 = (Dali::CameraActor *)jarg1;
44607   arg2 = jarg2 ? true : false;
44608   {
44609     try {
44610       (arg1)->SetInvertYAxis(arg2);
44611     } catch (std::out_of_range& e) {
44612       {
44613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44614       };
44615     } catch (std::exception& e) {
44616       {
44617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44618       };
44619     } catch (...) {
44620       {
44621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44622       };
44623     }
44624   }
44625 }
44626
44627
44628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44629   unsigned int jresult ;
44630   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44631   bool result;
44632
44633   arg1 = (Dali::CameraActor *)jarg1;
44634   {
44635     try {
44636       result = (bool)(arg1)->GetInvertYAxis();
44637     } catch (std::out_of_range& e) {
44638       {
44639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44640       };
44641     } catch (std::exception& e) {
44642       {
44643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44644       };
44645     } catch (...) {
44646       {
44647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44648       };
44649     }
44650   }
44651   jresult = result;
44652   return jresult;
44653 }
44654
44655
44656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44658   Dali::Size *arg2 = 0 ;
44659
44660   arg1 = (Dali::CameraActor *)jarg1;
44661   arg2 = (Dali::Size *)jarg2;
44662   if (!arg2) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44664     return ;
44665   }
44666   {
44667     try {
44668       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44676       };
44677     } catch (...) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44680       };
44681     }
44682   }
44683 }
44684
44685
44686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44687   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44688   Dali::Size *arg2 = 0 ;
44689
44690   arg1 = (Dali::CameraActor *)jarg1;
44691   arg2 = (Dali::Size *)jarg2;
44692   if (!arg2) {
44693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44694     return ;
44695   }
44696   {
44697     try {
44698       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44710       };
44711     }
44712   }
44713 }
44714
44715
44716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44717   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44718   float arg2 ;
44719   float arg3 ;
44720   float arg4 ;
44721   float arg5 ;
44722   float arg6 ;
44723   float arg7 ;
44724
44725   arg1 = (Dali::CameraActor *)jarg1;
44726   arg2 = (float)jarg2;
44727   arg3 = (float)jarg3;
44728   arg4 = (float)jarg4;
44729   arg5 = (float)jarg5;
44730   arg6 = (float)jarg6;
44731   arg7 = (float)jarg7;
44732   {
44733     try {
44734       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44735     } catch (std::out_of_range& e) {
44736       {
44737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44738       };
44739     } catch (std::exception& e) {
44740       {
44741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44742       };
44743     } catch (...) {
44744       {
44745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44746       };
44747     }
44748   }
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44753   void * jresult ;
44754   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44755
44756   {
44757     try {
44758       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44766       };
44767     } catch (...) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44770       };
44771     }
44772   }
44773   jresult = (void *)result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44779   void * jresult ;
44780   std::string arg1 ;
44781   Dali::Property::Value arg2 ;
44782   Dali::Property::Value *argp2 ;
44783   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44784
44785   if (!jarg1) {
44786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44787     return 0;
44788   }
44789   (&arg1)->assign(jarg1);
44790   argp2 = (Dali::Property::Value *)jarg2;
44791   if (!argp2) {
44792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44793     return 0;
44794   }
44795   arg2 = *argp2;
44796   {
44797     try {
44798       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44799     } catch (std::out_of_range& e) {
44800       {
44801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44802       };
44803     } catch (std::exception& e) {
44804       {
44805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44806       };
44807     } catch (...) {
44808       {
44809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44810       };
44811     }
44812   }
44813   jresult = (void *)result;
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44819   void * jresult ;
44820   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44821   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44822
44823   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44824   if (!arg1) {
44825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44826     return 0;
44827   }
44828   {
44829     try {
44830       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
44831     } catch (std::out_of_range& e) {
44832       {
44833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (std::exception& e) {
44836       {
44837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44838       };
44839     } catch (...) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44842       };
44843     }
44844   }
44845   jresult = (void *)result;
44846   return jresult;
44847 }
44848
44849
44850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44851   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44852   std::string *arg2 = 0 ;
44853
44854   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44855   if (!jarg2) {
44856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44857     return ;
44858   }
44859   std::string arg2_str(jarg2);
44860   arg2 = &arg2_str;
44861   if (arg1) (arg1)->first = *arg2;
44862
44863   //argout typemap for const std::string&
44864
44865 }
44866
44867
44868 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44869   char * jresult ;
44870   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44871   std::string *result = 0 ;
44872
44873   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44874   result = (std::string *) & ((arg1)->first);
44875   jresult = SWIG_csharp_string_callback(result->c_str());
44876   return jresult;
44877 }
44878
44879
44880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44881   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44882   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44883
44884   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44885   arg2 = (Dali::Property::Value *)jarg2;
44886   if (arg1) (arg1)->second = *arg2;
44887 }
44888
44889
44890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44891   void * jresult ;
44892   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44893   Dali::Property::Value *result = 0 ;
44894
44895   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44896   result = (Dali::Property::Value *)& ((arg1)->second);
44897   jresult = (void *)result;
44898   return jresult;
44899 }
44900
44901
44902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44903   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44904
44905   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44906   {
44907     try {
44908       delete arg1;
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (...) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44920       };
44921     }
44922   }
44923 }
44924
44925
44926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44927   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44928
44929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44930   {
44931     try {
44932       (arg1)->clear();
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44940       };
44941     } catch (...) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44944       };
44945     }
44946   }
44947 }
44948
44949
44950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44951   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44952   Dali::TouchPoint *arg2 = 0 ;
44953
44954   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44955   arg2 = (Dali::TouchPoint *)jarg2;
44956   if (!arg2) {
44957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44958     return ;
44959   }
44960   {
44961     try {
44962       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44963     } catch (std::out_of_range& e) {
44964       {
44965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44966       };
44967     } catch (std::exception& e) {
44968       {
44969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44970       };
44971     } catch (...) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44974       };
44975     }
44976   }
44977 }
44978
44979
44980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44981   unsigned long jresult ;
44982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44983   std::vector< Dali::TouchPoint >::size_type result;
44984
44985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44986   {
44987     try {
44988       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45000       };
45001     }
45002   }
45003   jresult = (unsigned long)result;
45004   return jresult;
45005 }
45006
45007
45008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45009   unsigned long jresult ;
45010   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45011   std::vector< Dali::TouchPoint >::size_type result;
45012
45013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45014   {
45015     try {
45016       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45017     } catch (std::out_of_range& e) {
45018       {
45019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (std::exception& e) {
45022       {
45023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (...) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45028       };
45029     }
45030   }
45031   jresult = (unsigned long)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45037   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45038   std::vector< Dali::TouchPoint >::size_type arg2 ;
45039
45040   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45041   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45042   {
45043     try {
45044       (arg1)->reserve(arg2);
45045     } catch (std::out_of_range& e) {
45046       {
45047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (std::exception& e) {
45050       {
45051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059 }
45060
45061
45062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45063   void * jresult ;
45064   std::vector< Dali::TouchPoint > *result = 0 ;
45065
45066   {
45067     try {
45068       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45069     } catch (std::out_of_range& e) {
45070       {
45071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45072       };
45073     } catch (std::exception& e) {
45074       {
45075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (...) {
45078       {
45079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45080       };
45081     }
45082   }
45083   jresult = (void *)result;
45084   return jresult;
45085 }
45086
45087
45088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45089   void * jresult ;
45090   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45091   std::vector< Dali::TouchPoint > *result = 0 ;
45092
45093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45094   if (!arg1) {
45095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45096     return 0;
45097   }
45098   {
45099     try {
45100       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45101     } catch (std::out_of_range& e) {
45102       {
45103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45104       };
45105     } catch (std::exception& e) {
45106       {
45107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45112       };
45113     }
45114   }
45115   jresult = (void *)result;
45116   return jresult;
45117 }
45118
45119
45120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45121   void * jresult ;
45122   int arg1 ;
45123   std::vector< Dali::TouchPoint > *result = 0 ;
45124
45125   arg1 = (int)jarg1;
45126   {
45127     try {
45128       try {
45129         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45130       }
45131       catch(std::out_of_range &_e) {
45132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45133         return 0;
45134       }
45135
45136     } catch (std::out_of_range& e) {
45137       {
45138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45139       };
45140     } catch (std::exception& e) {
45141       {
45142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45143       };
45144     } catch (...) {
45145       {
45146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45147       };
45148     }
45149   }
45150   jresult = (void *)result;
45151   return jresult;
45152 }
45153
45154
45155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45156   void * jresult ;
45157   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45158   int arg2 ;
45159   SwigValueWrapper< Dali::TouchPoint > result;
45160
45161   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45162   arg2 = (int)jarg2;
45163   {
45164     try {
45165       try {
45166         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45167       }
45168       catch(std::out_of_range &_e) {
45169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45170         return 0;
45171       }
45172
45173     } catch (std::out_of_range& e) {
45174       {
45175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45176       };
45177     } catch (std::exception& e) {
45178       {
45179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45180       };
45181     } catch (...) {
45182       {
45183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45184       };
45185     }
45186   }
45187   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45188   return jresult;
45189 }
45190
45191
45192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45193   void * jresult ;
45194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45195   int arg2 ;
45196   Dali::TouchPoint *result = 0 ;
45197
45198   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45199   arg2 = (int)jarg2;
45200   {
45201     try {
45202       try {
45203         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45204       }
45205       catch(std::out_of_range &_e) {
45206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45207         return 0;
45208       }
45209
45210     } catch (std::out_of_range& e) {
45211       {
45212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45213       };
45214     } catch (std::exception& e) {
45215       {
45216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45217       };
45218     } catch (...) {
45219       {
45220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45221       };
45222     }
45223   }
45224   jresult = (void *)result;
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45230   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45231   int arg2 ;
45232   Dali::TouchPoint *arg3 = 0 ;
45233
45234   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45235   arg2 = (int)jarg2;
45236   arg3 = (Dali::TouchPoint *)jarg3;
45237   if (!arg3) {
45238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45239     return ;
45240   }
45241   {
45242     try {
45243       try {
45244         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45245       }
45246       catch(std::out_of_range &_e) {
45247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45248         return ;
45249       }
45250
45251     } catch (std::out_of_range& e) {
45252       {
45253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45254       };
45255     } catch (std::exception& e) {
45256       {
45257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45258       };
45259     } catch (...) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45262       };
45263     }
45264   }
45265 }
45266
45267
45268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45269   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45270   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45271
45272   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45273   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45274   if (!arg2) {
45275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45276     return ;
45277   }
45278   {
45279     try {
45280       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45281     } catch (std::out_of_range& e) {
45282       {
45283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (std::exception& e) {
45286       {
45287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45292       };
45293     }
45294   }
45295 }
45296
45297
45298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45299   void * jresult ;
45300   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45301   int arg2 ;
45302   int arg3 ;
45303   std::vector< Dali::TouchPoint > *result = 0 ;
45304
45305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45306   arg2 = (int)jarg2;
45307   arg3 = (int)jarg3;
45308   {
45309     try {
45310       try {
45311         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45312       }
45313       catch(std::out_of_range &_e) {
45314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45315         return 0;
45316       }
45317       catch(std::invalid_argument &_e) {
45318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45319         return 0;
45320       }
45321
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45333       };
45334     }
45335   }
45336   jresult = (void *)result;
45337   return jresult;
45338 }
45339
45340
45341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45342   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45343   int arg2 ;
45344   Dali::TouchPoint *arg3 = 0 ;
45345
45346   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45347   arg2 = (int)jarg2;
45348   arg3 = (Dali::TouchPoint *)jarg3;
45349   if (!arg3) {
45350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45351     return ;
45352   }
45353   {
45354     try {
45355       try {
45356         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45357       }
45358       catch(std::out_of_range &_e) {
45359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45360         return ;
45361       }
45362
45363     } catch (std::out_of_range& e) {
45364       {
45365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45366       };
45367     } catch (std::exception& e) {
45368       {
45369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45370       };
45371     } catch (...) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45374       };
45375     }
45376   }
45377 }
45378
45379
45380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45381   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45382   int arg2 ;
45383   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45384
45385   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45386   arg2 = (int)jarg2;
45387   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45388   if (!arg3) {
45389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45390     return ;
45391   }
45392   {
45393     try {
45394       try {
45395         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45396       }
45397       catch(std::out_of_range &_e) {
45398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45399         return ;
45400       }
45401
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45413       };
45414     }
45415   }
45416 }
45417
45418
45419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45420   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45421   int arg2 ;
45422
45423   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45424   arg2 = (int)jarg2;
45425   {
45426     try {
45427       try {
45428         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45429       }
45430       catch(std::out_of_range &_e) {
45431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45432         return ;
45433       }
45434
45435     } catch (std::out_of_range& e) {
45436       {
45437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45438       };
45439     } catch (std::exception& e) {
45440       {
45441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45442       };
45443     } catch (...) {
45444       {
45445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45446       };
45447     }
45448   }
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45454   int arg2 ;
45455   int arg3 ;
45456
45457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45458   arg2 = (int)jarg2;
45459   arg3 = (int)jarg3;
45460   {
45461     try {
45462       try {
45463         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45464       }
45465       catch(std::out_of_range &_e) {
45466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45467         return ;
45468       }
45469       catch(std::invalid_argument &_e) {
45470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45471         return ;
45472       }
45473
45474     } catch (std::out_of_range& e) {
45475       {
45476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45477       };
45478     } catch (std::exception& e) {
45479       {
45480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45485       };
45486     }
45487   }
45488 }
45489
45490
45491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45492   void * jresult ;
45493   Dali::TouchPoint *arg1 = 0 ;
45494   int arg2 ;
45495   std::vector< Dali::TouchPoint > *result = 0 ;
45496
45497   arg1 = (Dali::TouchPoint *)jarg1;
45498   if (!arg1) {
45499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45500     return 0;
45501   }
45502   arg2 = (int)jarg2;
45503   {
45504     try {
45505       try {
45506         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45507       }
45508       catch(std::out_of_range &_e) {
45509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45510         return 0;
45511       }
45512
45513     } catch (std::out_of_range& e) {
45514       {
45515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45516       };
45517     } catch (std::exception& e) {
45518       {
45519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45520       };
45521     } catch (...) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45524       };
45525     }
45526   }
45527   jresult = (void *)result;
45528   return jresult;
45529 }
45530
45531
45532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45533   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45534
45535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45536   {
45537     try {
45538       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (...) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45550       };
45551     }
45552   }
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45557   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45558   int arg2 ;
45559   int arg3 ;
45560
45561   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45562   arg2 = (int)jarg2;
45563   arg3 = (int)jarg3;
45564   {
45565     try {
45566       try {
45567         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45568       }
45569       catch(std::out_of_range &_e) {
45570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45571         return ;
45572       }
45573       catch(std::invalid_argument &_e) {
45574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45575         return ;
45576       }
45577
45578     } catch (std::out_of_range& e) {
45579       {
45580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45581       };
45582     } catch (std::exception& e) {
45583       {
45584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45585       };
45586     } catch (...) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45589       };
45590     }
45591   }
45592 }
45593
45594
45595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45596   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45597   int arg2 ;
45598   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45599
45600   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45601   arg2 = (int)jarg2;
45602   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45603   if (!arg3) {
45604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45605     return ;
45606   }
45607   {
45608     try {
45609       try {
45610         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45611       }
45612       catch(std::out_of_range &_e) {
45613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45614         return ;
45615       }
45616
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45628       };
45629     }
45630   }
45631 }
45632
45633
45634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45635   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45636
45637   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45638   {
45639     try {
45640       delete arg1;
45641     } catch (std::out_of_range& e) {
45642       {
45643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45644       };
45645     } catch (std::exception& e) {
45646       {
45647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45648       };
45649     } catch (...) {
45650       {
45651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45652       };
45653     }
45654   }
45655 }
45656
45657
45658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45659   void * jresult ;
45660   Dali::Rect< int > *result = 0 ;
45661
45662   {
45663     try {
45664       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679   jresult = (void *)result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45685   void * jresult ;
45686   int arg1 ;
45687   int arg2 ;
45688   int arg3 ;
45689   int arg4 ;
45690   Dali::Rect< int > *result = 0 ;
45691
45692   arg1 = (int)jarg1;
45693   arg2 = (int)jarg2;
45694   arg3 = (int)jarg3;
45695   arg4 = (int)jarg4;
45696   {
45697     try {
45698       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45699     } catch (std::out_of_range& e) {
45700       {
45701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45702       };
45703     } catch (std::exception& e) {
45704       {
45705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45710       };
45711     }
45712   }
45713   jresult = (void *)result;
45714   return jresult;
45715 }
45716
45717
45718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45719   void * jresult ;
45720   Dali::Rect< int > *arg1 = 0 ;
45721   Dali::Rect< int > *result = 0 ;
45722
45723   arg1 = (Dali::Rect< int > *)jarg1;
45724   if (!arg1) {
45725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45726     return 0;
45727   }
45728   {
45729     try {
45730       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45731     } catch (std::out_of_range& e) {
45732       {
45733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45734       };
45735     } catch (std::exception& e) {
45736       {
45737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45738       };
45739     } catch (...) {
45740       {
45741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45742       };
45743     }
45744   }
45745   jresult = (void *)result;
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45751   void * jresult ;
45752   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45753   Dali::Rect< int > *arg2 = 0 ;
45754   Dali::Rect< int > *result = 0 ;
45755
45756   arg1 = (Dali::Rect< int > *)jarg1;
45757   arg2 = (Dali::Rect< int > *)jarg2;
45758   if (!arg2) {
45759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45760     return 0;
45761   }
45762   {
45763     try {
45764       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45765     } catch (std::out_of_range& e) {
45766       {
45767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (std::exception& e) {
45770       {
45771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779   jresult = (void *)result;
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45785   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45786   int arg2 ;
45787   int arg3 ;
45788   int arg4 ;
45789   int arg5 ;
45790
45791   arg1 = (Dali::Rect< int > *)jarg1;
45792   arg2 = (int)jarg2;
45793   arg3 = (int)jarg3;
45794   arg4 = (int)jarg4;
45795   arg5 = (int)jarg5;
45796   {
45797     try {
45798       (arg1)->Set(arg2,arg3,arg4,arg5);
45799     } catch (std::out_of_range& e) {
45800       {
45801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45802       };
45803     } catch (std::exception& e) {
45804       {
45805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45810       };
45811     }
45812   }
45813 }
45814
45815
45816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45817   unsigned int jresult ;
45818   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45819   bool result;
45820
45821   arg1 = (Dali::Rect< int > *)jarg1;
45822   {
45823     try {
45824       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (...) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45836       };
45837     }
45838   }
45839   jresult = result;
45840   return jresult;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45845   int jresult ;
45846   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45847   int result;
45848
45849   arg1 = (Dali::Rect< int > *)jarg1;
45850   {
45851     try {
45852       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (...) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45864       };
45865     }
45866   }
45867   jresult = result;
45868   return jresult;
45869 }
45870
45871
45872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45873   int jresult ;
45874   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45875   int result;
45876
45877   arg1 = (Dali::Rect< int > *)jarg1;
45878   {
45879     try {
45880       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45881     } catch (std::out_of_range& e) {
45882       {
45883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45884       };
45885     } catch (std::exception& e) {
45886       {
45887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45892       };
45893     }
45894   }
45895   jresult = result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45901   int jresult ;
45902   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45903   int result;
45904
45905   arg1 = (Dali::Rect< int > *)jarg1;
45906   {
45907     try {
45908       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (...) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45920       };
45921     }
45922   }
45923   jresult = result;
45924   return jresult;
45925 }
45926
45927
45928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45929   int jresult ;
45930   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45931   int result;
45932
45933   arg1 = (Dali::Rect< int > *)jarg1;
45934   {
45935     try {
45936       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45937     } catch (std::out_of_range& e) {
45938       {
45939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45940       };
45941     } catch (std::exception& e) {
45942       {
45943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45944       };
45945     } catch (...) {
45946       {
45947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45948       };
45949     }
45950   }
45951   jresult = result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45957   int jresult ;
45958   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45959   int result;
45960
45961   arg1 = (Dali::Rect< int > *)jarg1;
45962   {
45963     try {
45964       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45965     } catch (std::out_of_range& e) {
45966       {
45967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45968       };
45969     } catch (std::exception& e) {
45970       {
45971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45972       };
45973     } catch (...) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45976       };
45977     }
45978   }
45979   jresult = result;
45980   return jresult;
45981 }
45982
45983
45984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45985   unsigned int jresult ;
45986   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45987   Dali::Rect< int > *arg2 = 0 ;
45988   bool result;
45989
45990   arg1 = (Dali::Rect< int > *)jarg1;
45991   arg2 = (Dali::Rect< int > *)jarg2;
45992   if (!arg2) {
45993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45994     return 0;
45995   }
45996   {
45997     try {
45998       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45999     } catch (std::out_of_range& e) {
46000       {
46001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46002       };
46003     } catch (std::exception& e) {
46004       {
46005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46006       };
46007     } catch (...) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46010       };
46011     }
46012   }
46013   jresult = result;
46014   return jresult;
46015 }
46016
46017
46018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46019   unsigned int jresult ;
46020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46021   Dali::Rect< int > *arg2 = 0 ;
46022   bool result;
46023
46024   arg1 = (Dali::Rect< int > *)jarg1;
46025   arg2 = (Dali::Rect< int > *)jarg2;
46026   if (!arg2) {
46027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46028     return 0;
46029   }
46030   {
46031     try {
46032       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46033     } catch (std::out_of_range& e) {
46034       {
46035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46036       };
46037     } catch (std::exception& e) {
46038       {
46039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (...) {
46042       {
46043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46044       };
46045     }
46046   }
46047   jresult = result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
46053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46054   int arg2 ;
46055
46056   arg1 = (Dali::Rect< int > *)jarg1;
46057   arg2 = (int)jarg2;
46058   if (arg1) (arg1)->x = arg2;
46059 }
46060
46061
46062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
46063   int jresult ;
46064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46065   int result;
46066
46067   arg1 = (Dali::Rect< int > *)jarg1;
46068   result = (int) ((arg1)->x);
46069   jresult = result;
46070   return jresult;
46071 }
46072
46073
46074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
46075   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46076   int arg2 ;
46077
46078   arg1 = (Dali::Rect< int > *)jarg1;
46079   arg2 = (int)jarg2;
46080   if (arg1) (arg1)->left = arg2;
46081 }
46082
46083
46084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46085   int jresult ;
46086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46087   int result;
46088
46089   arg1 = (Dali::Rect< int > *)jarg1;
46090   result = (int) ((arg1)->left);
46091   jresult = result;
46092   return jresult;
46093 }
46094
46095
46096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46098   int arg2 ;
46099
46100   arg1 = (Dali::Rect< int > *)jarg1;
46101   arg2 = (int)jarg2;
46102   if (arg1) (arg1)->y = arg2;
46103 }
46104
46105
46106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46107   int jresult ;
46108   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46109   int result;
46110
46111   arg1 = (Dali::Rect< int > *)jarg1;
46112   result = (int) ((arg1)->y);
46113   jresult = result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46120   int arg2 ;
46121
46122   arg1 = (Dali::Rect< int > *)jarg1;
46123   arg2 = (int)jarg2;
46124   if (arg1) (arg1)->right = arg2;
46125 }
46126
46127
46128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46129   int jresult ;
46130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46131   int result;
46132
46133   arg1 = (Dali::Rect< int > *)jarg1;
46134   result = (int) ((arg1)->right);
46135   jresult = result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46141   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46142   int arg2 ;
46143
46144   arg1 = (Dali::Rect< int > *)jarg1;
46145   arg2 = (int)jarg2;
46146   if (arg1) (arg1)->width = arg2;
46147 }
46148
46149
46150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46151   int jresult ;
46152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46153   int result;
46154
46155   arg1 = (Dali::Rect< int > *)jarg1;
46156   result = (int) ((arg1)->width);
46157   jresult = result;
46158   return jresult;
46159 }
46160
46161
46162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46164   int arg2 ;
46165
46166   arg1 = (Dali::Rect< int > *)jarg1;
46167   arg2 = (int)jarg2;
46168   if (arg1) (arg1)->bottom = arg2;
46169 }
46170
46171
46172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46173   int jresult ;
46174   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46175   int result;
46176
46177   arg1 = (Dali::Rect< int > *)jarg1;
46178   result = (int) ((arg1)->bottom);
46179   jresult = result;
46180   return jresult;
46181 }
46182
46183
46184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46186   int arg2 ;
46187
46188   arg1 = (Dali::Rect< int > *)jarg1;
46189   arg2 = (int)jarg2;
46190   if (arg1) (arg1)->height = arg2;
46191 }
46192
46193
46194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46195   int jresult ;
46196   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46197   int result;
46198
46199   arg1 = (Dali::Rect< int > *)jarg1;
46200   result = (int) ((arg1)->height);
46201   jresult = result;
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46207   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46208   int arg2 ;
46209
46210   arg1 = (Dali::Rect< int > *)jarg1;
46211   arg2 = (int)jarg2;
46212   if (arg1) (arg1)->top = arg2;
46213 }
46214
46215
46216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46217   int jresult ;
46218   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46219   int result;
46220
46221   arg1 = (Dali::Rect< int > *)jarg1;
46222   result = (int) ((arg1)->top);
46223   jresult = result;
46224   return jresult;
46225 }
46226
46227
46228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46229   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46230
46231   arg1 = (Dali::Rect< int > *)jarg1;
46232   {
46233     try {
46234       delete arg1;
46235     } catch (std::out_of_range& e) {
46236       {
46237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46238       };
46239     } catch (std::exception& e) {
46240       {
46241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46242       };
46243     } catch (...) {
46244       {
46245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46246       };
46247     }
46248   }
46249 }
46250
46251
46252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46253   void * jresult ;
46254   Dali::Rect< float > *result = 0 ;
46255
46256   {
46257     try {
46258       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46270       };
46271     }
46272   }
46273   jresult = (void *)result;
46274   return jresult;
46275 }
46276
46277
46278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46279   void * jresult ;
46280   float arg1 ;
46281   float arg2 ;
46282   float arg3 ;
46283   float arg4 ;
46284   Dali::Rect< float > *result = 0 ;
46285
46286   arg1 = (float)jarg1;
46287   arg2 = (float)jarg2;
46288   arg3 = (float)jarg3;
46289   arg4 = (float)jarg4;
46290   {
46291     try {
46292       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46300       };
46301     } catch (...) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46304       };
46305     }
46306   }
46307   jresult = (void *)result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46313   void * jresult ;
46314   Dali::Rect< float > *arg1 = 0 ;
46315   Dali::Rect< float > *result = 0 ;
46316
46317   arg1 = (Dali::Rect< float > *)jarg1;
46318   if (!arg1) {
46319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46320     return 0;
46321   }
46322   {
46323     try {
46324       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46325     } catch (std::out_of_range& e) {
46326       {
46327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46328       };
46329     } catch (std::exception& e) {
46330       {
46331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46332       };
46333     } catch (...) {
46334       {
46335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46336       };
46337     }
46338   }
46339   jresult = (void *)result;
46340   return jresult;
46341 }
46342
46343
46344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46345   void * jresult ;
46346   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46347   Dali::Rect< float > *arg2 = 0 ;
46348   Dali::Rect< float > *result = 0 ;
46349
46350   arg1 = (Dali::Rect< float > *)jarg1;
46351   arg2 = (Dali::Rect< float > *)jarg2;
46352   if (!arg2) {
46353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46354     return 0;
46355   }
46356   {
46357     try {
46358       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46359     } catch (std::out_of_range& e) {
46360       {
46361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46362       };
46363     } catch (std::exception& e) {
46364       {
46365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46366       };
46367     } catch (...) {
46368       {
46369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46370       };
46371     }
46372   }
46373   jresult = (void *)result;
46374   return jresult;
46375 }
46376
46377
46378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46379   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46380   float arg2 ;
46381   float arg3 ;
46382   float arg4 ;
46383   float arg5 ;
46384
46385   arg1 = (Dali::Rect< float > *)jarg1;
46386   arg2 = (float)jarg2;
46387   arg3 = (float)jarg3;
46388   arg4 = (float)jarg4;
46389   arg5 = (float)jarg5;
46390   {
46391     try {
46392       (arg1)->Set(arg2,arg3,arg4,arg5);
46393     } catch (std::out_of_range& e) {
46394       {
46395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46396       };
46397     } catch (std::exception& e) {
46398       {
46399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46400       };
46401     } catch (...) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46404       };
46405     }
46406   }
46407 }
46408
46409
46410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46411   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46412   float arg2 ;
46413
46414   arg1 = (Dali::Rect< float > *)jarg1;
46415   arg2 = (float)jarg2;
46416   if (arg1) (arg1)->x = arg2;
46417 }
46418
46419
46420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46421   float jresult ;
46422   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46423   float result;
46424
46425   arg1 = (Dali::Rect< float > *)jarg1;
46426   result = (float) ((arg1)->x);
46427   jresult = result;
46428   return jresult;
46429 }
46430
46431
46432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46433   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46434   float arg2 ;
46435
46436   arg1 = (Dali::Rect< float > *)jarg1;
46437   arg2 = (float)jarg2;
46438   if (arg1) (arg1)->left = arg2;
46439 }
46440
46441
46442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46443   float jresult ;
46444   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46445   float result;
46446
46447   arg1 = (Dali::Rect< float > *)jarg1;
46448   result = (float) ((arg1)->left);
46449   jresult = result;
46450   return jresult;
46451 }
46452
46453
46454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46455   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46456   float arg2 ;
46457
46458   arg1 = (Dali::Rect< float > *)jarg1;
46459   arg2 = (float)jarg2;
46460   if (arg1) (arg1)->y = arg2;
46461 }
46462
46463
46464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46465   float jresult ;
46466   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46467   float result;
46468
46469   arg1 = (Dali::Rect< float > *)jarg1;
46470   result = (float) ((arg1)->y);
46471   jresult = result;
46472   return jresult;
46473 }
46474
46475
46476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46477   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46478   float arg2 ;
46479
46480   arg1 = (Dali::Rect< float > *)jarg1;
46481   arg2 = (float)jarg2;
46482   if (arg1) (arg1)->right = arg2;
46483 }
46484
46485
46486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46487   float jresult ;
46488   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46489   float result;
46490
46491   arg1 = (Dali::Rect< float > *)jarg1;
46492   result = (float) ((arg1)->right);
46493   jresult = result;
46494   return jresult;
46495 }
46496
46497
46498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46500   float arg2 ;
46501
46502   arg1 = (Dali::Rect< float > *)jarg1;
46503   arg2 = (float)jarg2;
46504   if (arg1) (arg1)->width = arg2;
46505 }
46506
46507
46508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46509   float jresult ;
46510   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46511   float result;
46512
46513   arg1 = (Dali::Rect< float > *)jarg1;
46514   result = (float) ((arg1)->width);
46515   jresult = result;
46516   return jresult;
46517 }
46518
46519
46520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46522   float arg2 ;
46523
46524   arg1 = (Dali::Rect< float > *)jarg1;
46525   arg2 = (float)jarg2;
46526   if (arg1) (arg1)->bottom = arg2;
46527 }
46528
46529
46530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46531   float jresult ;
46532   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46533   float result;
46534
46535   arg1 = (Dali::Rect< float > *)jarg1;
46536   result = (float) ((arg1)->bottom);
46537   jresult = result;
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46543   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46544   float arg2 ;
46545
46546   arg1 = (Dali::Rect< float > *)jarg1;
46547   arg2 = (float)jarg2;
46548   if (arg1) (arg1)->height = arg2;
46549 }
46550
46551
46552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46553   float jresult ;
46554   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46555   float result;
46556
46557   arg1 = (Dali::Rect< float > *)jarg1;
46558   result = (float) ((arg1)->height);
46559   jresult = result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46565   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46566   float arg2 ;
46567
46568   arg1 = (Dali::Rect< float > *)jarg1;
46569   arg2 = (float)jarg2;
46570   if (arg1) (arg1)->top = arg2;
46571 }
46572
46573
46574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46575   float jresult ;
46576   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46577   float result;
46578
46579   arg1 = (Dali::Rect< float > *)jarg1;
46580   result = (float) ((arg1)->top);
46581   jresult = result;
46582   return jresult;
46583 }
46584
46585
46586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46587   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46588
46589   arg1 = (Dali::Rect< float > *)jarg1;
46590   {
46591     try {
46592       delete arg1;
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46600       };
46601     } catch (...) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46604       };
46605     }
46606   }
46607 }
46608
46609
46610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46611   int jresult ;
46612   int result;
46613
46614   result = (int)Dali::Vector< int >::BaseType;
46615   jresult = (int)result;
46616   return jresult;
46617 }
46618
46619
46620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46621   void * jresult ;
46622   Dali::Vector< int > *result = 0 ;
46623
46624   {
46625     try {
46626       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46627     } catch (std::out_of_range& e) {
46628       {
46629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (std::exception& e) {
46632       {
46633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641   jresult = (void *)result;
46642   return jresult;
46643 }
46644
46645
46646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46647   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46648
46649   arg1 = (Dali::Vector< int > *)jarg1;
46650   {
46651     try {
46652       delete arg1;
46653     } catch (std::out_of_range& e) {
46654       {
46655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46656       };
46657     } catch (std::exception& e) {
46658       {
46659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46660       };
46661     } catch (...) {
46662       {
46663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46664       };
46665     }
46666   }
46667 }
46668
46669
46670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46671   void * jresult ;
46672   Dali::Vector< int > *arg1 = 0 ;
46673   Dali::Vector< int > *result = 0 ;
46674
46675   arg1 = (Dali::Vector< int > *)jarg1;
46676   if (!arg1) {
46677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46678     return 0;
46679   }
46680   {
46681     try {
46682       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (...) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46694       };
46695     }
46696   }
46697   jresult = (void *)result;
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46703   void * jresult ;
46704   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46705   Dali::Vector< int > *arg2 = 0 ;
46706   Dali::Vector< int > *result = 0 ;
46707
46708   arg1 = (Dali::Vector< int > *)jarg1;
46709   arg2 = (Dali::Vector< int > *)jarg2;
46710   if (!arg2) {
46711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46712     return 0;
46713   }
46714   {
46715     try {
46716       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46717     } catch (std::out_of_range& e) {
46718       {
46719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46720       };
46721     } catch (std::exception& e) {
46722       {
46723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46724       };
46725     } catch (...) {
46726       {
46727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46728       };
46729     }
46730   }
46731   jresult = (void *)result;
46732   return jresult;
46733 }
46734
46735
46736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46737   void * jresult ;
46738   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46739   Dali::Vector< int >::Iterator result;
46740
46741   arg1 = (Dali::Vector< int > *)jarg1;
46742   {
46743     try {
46744       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46745     } catch (std::out_of_range& e) {
46746       {
46747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46748       };
46749     } catch (std::exception& e) {
46750       {
46751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46752       };
46753     } catch (...) {
46754       {
46755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46756       };
46757     }
46758   }
46759   jresult = (void *)result;
46760   return jresult;
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46765   void * jresult ;
46766   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46767   Dali::Vector< int >::Iterator result;
46768
46769   arg1 = (Dali::Vector< int > *)jarg1;
46770   {
46771     try {
46772       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46784       };
46785     }
46786   }
46787   jresult = (void *)result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46793   void * jresult ;
46794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46795   Dali::Vector< int >::SizeType arg2 ;
46796   Dali::Vector< int >::ItemType *result = 0 ;
46797
46798   arg1 = (Dali::Vector< int > *)jarg1;
46799   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46800   {
46801     try {
46802       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46803     } catch (std::out_of_range& e) {
46804       {
46805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46806       };
46807     } catch (std::exception& e) {
46808       {
46809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46810       };
46811     } catch (...) {
46812       {
46813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46814       };
46815     }
46816   }
46817   jresult = (void *)result;
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46823   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46824   Dali::Vector< int >::ItemType *arg2 = 0 ;
46825   Dali::Vector< int >::ItemType temp2 ;
46826
46827   arg1 = (Dali::Vector< int > *)jarg1;
46828   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46829   arg2 = &temp2;
46830   {
46831     try {
46832       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46833     } catch (std::out_of_range& e) {
46834       {
46835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46836       };
46837     } catch (std::exception& e) {
46838       {
46839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46840       };
46841     } catch (...) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46844       };
46845     }
46846   }
46847 }
46848
46849
46850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46851   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46852   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46853   Dali::Vector< int >::ItemType *arg3 = 0 ;
46854   Dali::Vector< int >::ItemType temp3 ;
46855
46856   arg1 = (Dali::Vector< int > *)jarg1;
46857   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46858   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46859   arg3 = &temp3;
46860   {
46861     try {
46862       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (...) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46874       };
46875     }
46876   }
46877 }
46878
46879
46880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46881   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46882   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46883   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46884   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46885
46886   arg1 = (Dali::Vector< int > *)jarg1;
46887   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46888   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46889   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46890   {
46891     try {
46892       (arg1)->Insert(arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46900       };
46901     } catch (...) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46904       };
46905     }
46906   }
46907 }
46908
46909
46910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46911   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46912   Dali::Vector< int >::SizeType arg2 ;
46913
46914   arg1 = (Dali::Vector< int > *)jarg1;
46915   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46916   {
46917     try {
46918       (arg1)->Reserve(arg2);
46919     } catch (std::out_of_range& e) {
46920       {
46921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46922       };
46923     } catch (std::exception& e) {
46924       {
46925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46926       };
46927     } catch (...) {
46928       {
46929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46930       };
46931     }
46932   }
46933 }
46934
46935
46936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46937   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46938   Dali::Vector< int >::SizeType arg2 ;
46939
46940   arg1 = (Dali::Vector< int > *)jarg1;
46941   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46942   {
46943     try {
46944       (arg1)->Resize(arg2);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46952       };
46953     } catch (...) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46956       };
46957     }
46958   }
46959 }
46960
46961
46962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46963   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46964   Dali::Vector< int >::SizeType arg2 ;
46965   Dali::Vector< int >::ItemType *arg3 = 0 ;
46966   Dali::Vector< int >::ItemType temp3 ;
46967
46968   arg1 = (Dali::Vector< int > *)jarg1;
46969   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46970   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46971   arg3 = &temp3;
46972   {
46973     try {
46974       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46975     } catch (std::out_of_range& e) {
46976       {
46977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46978       };
46979     } catch (std::exception& e) {
46980       {
46981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46982       };
46983     } catch (...) {
46984       {
46985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46986       };
46987     }
46988   }
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46993   void * jresult ;
46994   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46995   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46996   Dali::Vector< int >::Iterator result;
46997
46998   arg1 = (Dali::Vector< int > *)jarg1;
46999   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47000   {
47001     try {
47002       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (...) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47014       };
47015     }
47016   }
47017   jresult = (void *)result;
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47023   void * jresult ;
47024   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47025   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47026   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47027   Dali::Vector< int >::Iterator result;
47028
47029   arg1 = (Dali::Vector< int > *)jarg1;
47030   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47031   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47032   {
47033     try {
47034       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (...) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47046       };
47047     }
47048   }
47049   jresult = (void *)result;
47050   return jresult;
47051 }
47052
47053
47054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
47055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47056   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47057
47058   arg1 = (Dali::Vector< int > *)jarg1;
47059   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47060   {
47061     try {
47062       (arg1)->Remove(arg2);
47063     } catch (std::out_of_range& e) {
47064       {
47065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47066       };
47067     } catch (std::exception& e) {
47068       {
47069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47070       };
47071     } catch (...) {
47072       {
47073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47074       };
47075     }
47076   }
47077 }
47078
47079
47080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47081   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47082   Dali::Vector< int > *arg2 = 0 ;
47083
47084   arg1 = (Dali::Vector< int > *)jarg1;
47085   arg2 = (Dali::Vector< int > *)jarg2;
47086   if (!arg2) {
47087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47088     return ;
47089   }
47090   {
47091     try {
47092       (arg1)->Swap(*arg2);
47093     } catch (std::out_of_range& e) {
47094       {
47095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47096       };
47097     } catch (std::exception& e) {
47098       {
47099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47100       };
47101     } catch (...) {
47102       {
47103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47104       };
47105     }
47106   }
47107 }
47108
47109
47110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47111   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47112
47113   arg1 = (Dali::Vector< int > *)jarg1;
47114   {
47115     try {
47116       (arg1)->Clear();
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (...) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47128       };
47129     }
47130   }
47131 }
47132
47133
47134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47135   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47136
47137   arg1 = (Dali::Vector< int > *)jarg1;
47138   {
47139     try {
47140       (arg1)->Release();
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47152       };
47153     }
47154   }
47155 }
47156
47157
47158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47159   int jresult ;
47160   int result;
47161
47162   result = (int)Dali::Vector< float >::BaseType;
47163   jresult = (int)result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47169   void * jresult ;
47170   Dali::Vector< float > *result = 0 ;
47171
47172   {
47173     try {
47174       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (...) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47186       };
47187     }
47188   }
47189   jresult = (void *)result;
47190   return jresult;
47191 }
47192
47193
47194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47195   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47196
47197   arg1 = (Dali::Vector< float > *)jarg1;
47198   {
47199     try {
47200       delete arg1;
47201     } catch (std::out_of_range& e) {
47202       {
47203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47204       };
47205     } catch (std::exception& e) {
47206       {
47207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (...) {
47210       {
47211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47212       };
47213     }
47214   }
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47219   void * jresult ;
47220   Dali::Vector< float > *arg1 = 0 ;
47221   Dali::Vector< float > *result = 0 ;
47222
47223   arg1 = (Dali::Vector< float > *)jarg1;
47224   if (!arg1) {
47225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47226     return 0;
47227   }
47228   {
47229     try {
47230       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245   jresult = (void *)result;
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47251   void * jresult ;
47252   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47253   Dali::Vector< float > *arg2 = 0 ;
47254   Dali::Vector< float > *result = 0 ;
47255
47256   arg1 = (Dali::Vector< float > *)jarg1;
47257   arg2 = (Dali::Vector< float > *)jarg2;
47258   if (!arg2) {
47259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47260     return 0;
47261   }
47262   {
47263     try {
47264       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47265     } catch (std::out_of_range& e) {
47266       {
47267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (std::exception& e) {
47270       {
47271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47272       };
47273     } catch (...) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47276       };
47277     }
47278   }
47279   jresult = (void *)result;
47280   return jresult;
47281 }
47282
47283
47284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47285   void * jresult ;
47286   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47287   Dali::Vector< float >::Iterator result;
47288
47289   arg1 = (Dali::Vector< float > *)jarg1;
47290   {
47291     try {
47292       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47293     } catch (std::out_of_range& e) {
47294       {
47295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (std::exception& e) {
47298       {
47299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47300       };
47301     } catch (...) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47304       };
47305     }
47306   }
47307   jresult = (void *)result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47313   void * jresult ;
47314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47315   Dali::Vector< float >::Iterator result;
47316
47317   arg1 = (Dali::Vector< float > *)jarg1;
47318   {
47319     try {
47320       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335   jresult = (void *)result;
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47341   void * jresult ;
47342   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47343   Dali::Vector< float >::SizeType arg2 ;
47344   Dali::Vector< float >::ItemType *result = 0 ;
47345
47346   arg1 = (Dali::Vector< float > *)jarg1;
47347   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47348   {
47349     try {
47350       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47358       };
47359     } catch (...) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47362       };
47363     }
47364   }
47365   jresult = (void *)result;
47366   return jresult;
47367 }
47368
47369
47370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47371   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47372   Dali::Vector< float >::ItemType *arg2 = 0 ;
47373   Dali::Vector< float >::ItemType temp2 ;
47374
47375   arg1 = (Dali::Vector< float > *)jarg1;
47376   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47377   arg2 = &temp2;
47378   {
47379     try {
47380       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47381     } catch (std::out_of_range& e) {
47382       {
47383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47384       };
47385     } catch (std::exception& e) {
47386       {
47387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47388       };
47389     } catch (...) {
47390       {
47391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47392       };
47393     }
47394   }
47395 }
47396
47397
47398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47399   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47400   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47401   Dali::Vector< float >::ItemType *arg3 = 0 ;
47402   Dali::Vector< float >::ItemType temp3 ;
47403
47404   arg1 = (Dali::Vector< float > *)jarg1;
47405   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47406   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47407   arg3 = &temp3;
47408   {
47409     try {
47410       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47411     } catch (std::out_of_range& e) {
47412       {
47413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47414       };
47415     } catch (std::exception& e) {
47416       {
47417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47418       };
47419     } catch (...) {
47420       {
47421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47422       };
47423     }
47424   }
47425 }
47426
47427
47428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47429   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47430   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47431   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47432   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47433
47434   arg1 = (Dali::Vector< float > *)jarg1;
47435   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47436   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47437   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47438   {
47439     try {
47440       (arg1)->Insert(arg2,arg3,arg4);
47441     } catch (std::out_of_range& e) {
47442       {
47443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47444       };
47445     } catch (std::exception& e) {
47446       {
47447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47448       };
47449     } catch (...) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47452       };
47453     }
47454   }
47455 }
47456
47457
47458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47460   Dali::Vector< float >::SizeType arg2 ;
47461
47462   arg1 = (Dali::Vector< float > *)jarg1;
47463   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47464   {
47465     try {
47466       (arg1)->Reserve(arg2);
47467     } catch (std::out_of_range& e) {
47468       {
47469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47470       };
47471     } catch (std::exception& e) {
47472       {
47473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47474       };
47475     } catch (...) {
47476       {
47477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47478       };
47479     }
47480   }
47481 }
47482
47483
47484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47485   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47486   Dali::Vector< float >::SizeType arg2 ;
47487
47488   arg1 = (Dali::Vector< float > *)jarg1;
47489   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47490   {
47491     try {
47492       (arg1)->Resize(arg2);
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47504       };
47505     }
47506   }
47507 }
47508
47509
47510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47511   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47512   Dali::Vector< float >::SizeType arg2 ;
47513   Dali::Vector< float >::ItemType *arg3 = 0 ;
47514   Dali::Vector< float >::ItemType temp3 ;
47515
47516   arg1 = (Dali::Vector< float > *)jarg1;
47517   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47518   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47519   arg3 = &temp3;
47520   {
47521     try {
47522       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (...) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47534       };
47535     }
47536   }
47537 }
47538
47539
47540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47541   void * jresult ;
47542   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47543   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47544   Dali::Vector< float >::Iterator result;
47545
47546   arg1 = (Dali::Vector< float > *)jarg1;
47547   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47548   {
47549     try {
47550       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47551     } catch (std::out_of_range& e) {
47552       {
47553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47554       };
47555     } catch (std::exception& e) {
47556       {
47557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47558       };
47559     } catch (...) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47562       };
47563     }
47564   }
47565   jresult = (void *)result;
47566   return jresult;
47567 }
47568
47569
47570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47571   void * jresult ;
47572   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47573   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47574   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47575   Dali::Vector< float >::Iterator result;
47576
47577   arg1 = (Dali::Vector< float > *)jarg1;
47578   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47579   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47580   {
47581     try {
47582       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47603   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47604   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47605
47606   arg1 = (Dali::Vector< float > *)jarg1;
47607   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47608   {
47609     try {
47610       (arg1)->Remove(arg2);
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47618       };
47619     } catch (...) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47622       };
47623     }
47624   }
47625 }
47626
47627
47628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47629   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47630   Dali::Vector< float > *arg2 = 0 ;
47631
47632   arg1 = (Dali::Vector< float > *)jarg1;
47633   arg2 = (Dali::Vector< float > *)jarg2;
47634   if (!arg2) {
47635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47636     return ;
47637   }
47638   {
47639     try {
47640       (arg1)->Swap(*arg2);
47641     } catch (std::out_of_range& e) {
47642       {
47643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47644       };
47645     } catch (std::exception& e) {
47646       {
47647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47652       };
47653     }
47654   }
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47659   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47660
47661   arg1 = (Dali::Vector< float > *)jarg1;
47662   {
47663     try {
47664       (arg1)->Clear();
47665     } catch (std::out_of_range& e) {
47666       {
47667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47668       };
47669     } catch (std::exception& e) {
47670       {
47671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47676       };
47677     }
47678   }
47679 }
47680
47681
47682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47683   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47684
47685   arg1 = (Dali::Vector< float > *)jarg1;
47686   {
47687     try {
47688       (arg1)->Release();
47689     } catch (std::out_of_range& e) {
47690       {
47691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47692       };
47693     } catch (std::exception& e) {
47694       {
47695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47700       };
47701     }
47702   }
47703 }
47704
47705
47706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47707   int jresult ;
47708   int result;
47709
47710   result = (int)Dali::Vector< unsigned char >::BaseType;
47711   jresult = (int)result;
47712   return jresult;
47713 }
47714
47715
47716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47717   void * jresult ;
47718   Dali::Vector< unsigned char > *result = 0 ;
47719
47720   {
47721     try {
47722       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47723     } catch (std::out_of_range& e) {
47724       {
47725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47726       };
47727     } catch (std::exception& e) {
47728       {
47729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (...) {
47732       {
47733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47734       };
47735     }
47736   }
47737   jresult = (void *)result;
47738   return jresult;
47739 }
47740
47741
47742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47743   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47744
47745   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47746   {
47747     try {
47748       delete arg1;
47749     } catch (std::out_of_range& e) {
47750       {
47751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47752       };
47753     } catch (std::exception& e) {
47754       {
47755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47756       };
47757     } catch (...) {
47758       {
47759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47760       };
47761     }
47762   }
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47767   void * jresult ;
47768   Dali::Vector< unsigned char > *arg1 = 0 ;
47769   Dali::Vector< unsigned char > *result = 0 ;
47770
47771   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47772   if (!arg1) {
47773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47774     return 0;
47775   }
47776   {
47777     try {
47778       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47779     } catch (std::out_of_range& e) {
47780       {
47781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (std::exception& e) {
47784       {
47785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47790       };
47791     }
47792   }
47793   jresult = (void *)result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47799   void * jresult ;
47800   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47801   Dali::Vector< unsigned char > *arg2 = 0 ;
47802   Dali::Vector< unsigned char > *result = 0 ;
47803
47804   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47805   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47806   if (!arg2) {
47807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47808     return 0;
47809   }
47810   {
47811     try {
47812       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47813     } catch (std::out_of_range& e) {
47814       {
47815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (std::exception& e) {
47818       {
47819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47833   void * jresult ;
47834   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47835   Dali::Vector< unsigned char >::Iterator result;
47836
47837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47838   {
47839     try {
47840       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47841     } catch (std::out_of_range& e) {
47842       {
47843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47844       };
47845     } catch (std::exception& e) {
47846       {
47847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (...) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47852       };
47853     }
47854   }
47855   jresult = (void *)result;
47856   return jresult;
47857 }
47858
47859
47860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47861   void * jresult ;
47862   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47863   Dali::Vector< unsigned char >::Iterator result;
47864
47865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47866   {
47867     try {
47868       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47869     } catch (std::out_of_range& e) {
47870       {
47871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (std::exception& e) {
47874       {
47875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883   jresult = (void *)result;
47884   return jresult;
47885 }
47886
47887
47888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47889   void * jresult ;
47890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47891   Dali::Vector< unsigned char >::SizeType arg2 ;
47892   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47893
47894   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47895   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47896   {
47897     try {
47898       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47899     } catch (std::out_of_range& e) {
47900       {
47901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47902       };
47903     } catch (std::exception& e) {
47904       {
47905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (...) {
47908       {
47909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47910       };
47911     }
47912   }
47913   jresult = (void *)result;
47914   return jresult;
47915 }
47916
47917
47918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47919   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47920   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47921   Dali::Vector< unsigned char >::ItemType temp2 ;
47922
47923   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47924   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47925   arg2 = &temp2;
47926   {
47927     try {
47928       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47929     } catch (std::out_of_range& e) {
47930       {
47931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47932       };
47933     } catch (std::exception& e) {
47934       {
47935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47940       };
47941     }
47942   }
47943 }
47944
47945
47946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47947   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47948   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47949   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47950   Dali::Vector< unsigned char >::ItemType temp3 ;
47951
47952   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47953   arg2 = jarg2;
47954   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47955   arg3 = &temp3;
47956   {
47957     try {
47958       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47959     } catch (std::out_of_range& e) {
47960       {
47961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47962       };
47963     } catch (std::exception& e) {
47964       {
47965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47966       };
47967     } catch (...) {
47968       {
47969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47970       };
47971     }
47972   }
47973
47974
47975 }
47976
47977
47978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47980   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47981   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47982   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47983
47984   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47985   arg2 = jarg2;
47986   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47987   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47988   {
47989     try {
47990       (arg1)->Insert(arg2,arg3,arg4);
47991     } catch (std::out_of_range& e) {
47992       {
47993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (std::exception& e) {
47996       {
47997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (...) {
48000       {
48001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48002       };
48003     }
48004   }
48005
48006
48007 }
48008
48009
48010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
48011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48012   Dali::Vector< unsigned char >::SizeType arg2 ;
48013
48014   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48015   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48016   {
48017     try {
48018       (arg1)->Reserve(arg2);
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48030       };
48031     }
48032   }
48033 }
48034
48035
48036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48037   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48038   Dali::Vector< unsigned char >::SizeType arg2 ;
48039
48040   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48041   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48042   {
48043     try {
48044       (arg1)->Resize(arg2);
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48056       };
48057     }
48058   }
48059 }
48060
48061
48062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
48063   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48064   Dali::Vector< unsigned char >::SizeType arg2 ;
48065   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48066   Dali::Vector< unsigned char >::ItemType temp3 ;
48067
48068   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48069   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48070   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48071   arg3 = &temp3;
48072   {
48073     try {
48074       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48075     } catch (std::out_of_range& e) {
48076       {
48077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48078       };
48079     } catch (std::exception& e) {
48080       {
48081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48082       };
48083     } catch (...) {
48084       {
48085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48086       };
48087     }
48088   }
48089 }
48090
48091
48092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48093   void * jresult ;
48094   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48095   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48096   Dali::Vector< unsigned char >::Iterator result;
48097
48098   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48099   arg2 = jarg2;
48100   {
48101     try {
48102       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48103     } catch (std::out_of_range& e) {
48104       {
48105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48106       };
48107     } catch (std::exception& e) {
48108       {
48109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (...) {
48112       {
48113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48114       };
48115     }
48116   }
48117   jresult = (void *)result;
48118
48119
48120   return jresult;
48121 }
48122
48123
48124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48125   void * jresult ;
48126   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48127   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48128   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48129   Dali::Vector< unsigned char >::Iterator result;
48130
48131   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48132   arg2 = jarg2;
48133   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48134   {
48135     try {
48136       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (...) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48148       };
48149     }
48150   }
48151   jresult = (void *)result;
48152
48153
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48159   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48160   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48161
48162   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48163   arg2 = jarg2;
48164   {
48165     try {
48166       (arg1)->Remove(arg2);
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (...) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48178       };
48179     }
48180   }
48181
48182
48183 }
48184
48185
48186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48187   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48188   Dali::Vector< unsigned char > *arg2 = 0 ;
48189
48190   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48191   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48192   if (!arg2) {
48193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48194     return ;
48195   }
48196   {
48197     try {
48198       (arg1)->Swap(*arg2);
48199     } catch (std::out_of_range& e) {
48200       {
48201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48202       };
48203     } catch (std::exception& e) {
48204       {
48205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48206       };
48207     } catch (...) {
48208       {
48209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48210       };
48211     }
48212   }
48213 }
48214
48215
48216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48217   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48218
48219   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48220   {
48221     try {
48222       (arg1)->Clear();
48223     } catch (std::out_of_range& e) {
48224       {
48225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48226       };
48227     } catch (std::exception& e) {
48228       {
48229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (...) {
48232       {
48233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48234       };
48235     }
48236   }
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48241   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48242
48243   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48244   {
48245     try {
48246       (arg1)->Release();
48247     } catch (std::out_of_range& e) {
48248       {
48249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (std::exception& e) {
48252       {
48253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261 }
48262
48263
48264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48265   int jresult ;
48266   int result;
48267
48268   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48269   jresult = (int)result;
48270   return jresult;
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48275   void * jresult ;
48276   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48277
48278   {
48279     try {
48280       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48281     } catch (std::out_of_range& e) {
48282       {
48283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48284       };
48285     } catch (std::exception& e) {
48286       {
48287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48288       };
48289     } catch (...) {
48290       {
48291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48292       };
48293     }
48294   }
48295   jresult = (void *)result;
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48302
48303   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48304   {
48305     try {
48306       delete arg1;
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48318       };
48319     }
48320   }
48321 }
48322
48323
48324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48325   void * jresult ;
48326   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48327   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48328
48329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48330   if (!arg1) {
48331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48332     return 0;
48333   }
48334   {
48335     try {
48336       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48337     } catch (std::out_of_range& e) {
48338       {
48339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48340       };
48341     } catch (std::exception& e) {
48342       {
48343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48344       };
48345     } catch (...) {
48346       {
48347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48348       };
48349     }
48350   }
48351   jresult = (void *)result;
48352   return jresult;
48353 }
48354
48355
48356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48357   void * jresult ;
48358   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48359   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48360   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48361
48362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48363   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48364   if (!arg2) {
48365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48366     return 0;
48367   }
48368   {
48369     try {
48370       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48371     } catch (std::out_of_range& e) {
48372       {
48373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48374       };
48375     } catch (std::exception& e) {
48376       {
48377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48378       };
48379     } catch (...) {
48380       {
48381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48382       };
48383     }
48384   }
48385   jresult = (void *)result;
48386   return jresult;
48387 }
48388
48389
48390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48391   void * jresult ;
48392   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48393   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48394
48395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48396   {
48397     try {
48398       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48406       };
48407     } catch (...) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48410       };
48411     }
48412   }
48413   jresult = (void *)result;
48414   return jresult;
48415 }
48416
48417
48418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48419   void * jresult ;
48420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48421   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48422
48423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48424   {
48425     try {
48426       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48427     } catch (std::out_of_range& e) {
48428       {
48429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48430       };
48431     } catch (std::exception& e) {
48432       {
48433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48438       };
48439     }
48440   }
48441   jresult = (void *)result;
48442   return jresult;
48443 }
48444
48445
48446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48447   void * jresult ;
48448   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48449   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48450   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48451
48452   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48453   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48454   {
48455     try {
48456       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48457     } catch (std::out_of_range& e) {
48458       {
48459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48460       };
48461     } catch (std::exception& e) {
48462       {
48463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48464       };
48465     } catch (...) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48468       };
48469     }
48470   }
48471   jresult = (void *)result;
48472   return jresult;
48473 }
48474
48475
48476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48477   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48478   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48479
48480   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48481   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48482   if (!arg2) {
48483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48484     return ;
48485   }
48486   {
48487     try {
48488       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48489     } catch (std::out_of_range& e) {
48490       {
48491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48492       };
48493     } catch (std::exception& e) {
48494       {
48495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48496       };
48497     } catch (...) {
48498       {
48499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48500       };
48501     }
48502   }
48503 }
48504
48505
48506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48507   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48508   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48509   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48510
48511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48512   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48513   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48514   if (!arg3) {
48515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48516     return ;
48517   }
48518   {
48519     try {
48520       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535 }
48536
48537
48538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48540   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48541   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48542   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48543
48544   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48545   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48546   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48547   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48548   {
48549     try {
48550       (arg1)->Insert(arg2,arg3,arg4);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (...) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48562       };
48563     }
48564   }
48565 }
48566
48567
48568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48569   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48570   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48571
48572   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48573   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48574   {
48575     try {
48576       (arg1)->Reserve(arg2);
48577     } catch (std::out_of_range& e) {
48578       {
48579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48580       };
48581     } catch (std::exception& e) {
48582       {
48583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48584       };
48585     } catch (...) {
48586       {
48587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48588       };
48589     }
48590   }
48591 }
48592
48593
48594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48595   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48596   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48597
48598   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48599   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48600   {
48601     try {
48602       (arg1)->Resize(arg2);
48603     } catch (std::out_of_range& e) {
48604       {
48605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (std::exception& e) {
48608       {
48609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617 }
48618
48619
48620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48621   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48622   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48623   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48624
48625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48626   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48627   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48628   if (!arg3) {
48629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48630     return ;
48631   }
48632   {
48633     try {
48634       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48635     } catch (std::out_of_range& e) {
48636       {
48637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48638       };
48639     } catch (std::exception& e) {
48640       {
48641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (...) {
48644       {
48645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48646       };
48647     }
48648   }
48649 }
48650
48651
48652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48653   void * jresult ;
48654   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48655   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48656   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48657
48658   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48659   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48660   {
48661     try {
48662       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48663     } catch (std::out_of_range& e) {
48664       {
48665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48666       };
48667     } catch (std::exception& e) {
48668       {
48669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48670       };
48671     } catch (...) {
48672       {
48673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48674       };
48675     }
48676   }
48677   jresult = (void *)result;
48678   return jresult;
48679 }
48680
48681
48682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48683   void * jresult ;
48684   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48685   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48686   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48687   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48688
48689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48690   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48691   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48692   {
48693     try {
48694       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48695     } catch (std::out_of_range& e) {
48696       {
48697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48698       };
48699     } catch (std::exception& e) {
48700       {
48701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48702       };
48703     } catch (...) {
48704       {
48705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48706       };
48707     }
48708   }
48709   jresult = (void *)result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48715   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48716   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48717
48718   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48719   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48720   {
48721     try {
48722       (arg1)->Remove(arg2);
48723     } catch (std::out_of_range& e) {
48724       {
48725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (std::exception& e) {
48728       {
48729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (...) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48734       };
48735     }
48736   }
48737 }
48738
48739
48740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48741   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48742   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48743
48744   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48745   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48746   if (!arg2) {
48747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48748     return ;
48749   }
48750   {
48751     try {
48752       (arg1)->Swap(*arg2);
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48764       };
48765     }
48766   }
48767 }
48768
48769
48770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48771   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48772
48773   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48774   {
48775     try {
48776       (arg1)->Clear();
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (...) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48788       };
48789     }
48790   }
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48795   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48796
48797   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48798   {
48799     try {
48800       (arg1)->Release();
48801     } catch (std::out_of_range& e) {
48802       {
48803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48804       };
48805     } catch (std::exception& e) {
48806       {
48807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48808       };
48809     } catch (...) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48812       };
48813     }
48814   }
48815 }
48816
48817
48818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48819   void * jresult ;
48820   Dali::Signal< void () > *result = 0 ;
48821
48822   {
48823     try {
48824       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48825     } catch (std::out_of_range& e) {
48826       {
48827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (std::exception& e) {
48830       {
48831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48836       };
48837     }
48838   }
48839   jresult = (void *)result;
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48845   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48846
48847   arg1 = (Dali::Signal< void () > *)jarg1;
48848   {
48849     try {
48850       delete arg1;
48851     } catch (std::out_of_range& e) {
48852       {
48853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48854       };
48855     } catch (std::exception& e) {
48856       {
48857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48858       };
48859     } catch (...) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48862       };
48863     }
48864   }
48865 }
48866
48867
48868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48869   unsigned int jresult ;
48870   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48871   bool result;
48872
48873   arg1 = (Dali::Signal< void () > *)jarg1;
48874   {
48875     try {
48876       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48877     } catch (std::out_of_range& e) {
48878       {
48879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48880       };
48881     } catch (std::exception& e) {
48882       {
48883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48884       };
48885     } catch (...) {
48886       {
48887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48888       };
48889     }
48890   }
48891   jresult = result;
48892   return jresult;
48893 }
48894
48895
48896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48897   unsigned long jresult ;
48898   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48899   std::size_t result;
48900
48901   arg1 = (Dali::Signal< void () > *)jarg1;
48902   {
48903     try {
48904       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48905     } catch (std::out_of_range& e) {
48906       {
48907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48908       };
48909     } catch (std::exception& e) {
48910       {
48911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48912       };
48913     } catch (...) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48916       };
48917     }
48918   }
48919   jresult = (unsigned long)result;
48920   return jresult;
48921 }
48922
48923
48924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48925   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48926   void (*arg2)() = (void (*)()) 0 ;
48927
48928   arg1 = (Dali::Signal< void () > *)jarg1;
48929   arg2 = (void (*)())jarg2;
48930   {
48931     try {
48932       (arg1)->Connect(arg2);
48933     } catch (std::out_of_range& e) {
48934       {
48935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48936       };
48937     } catch (std::exception& e) {
48938       {
48939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48940       };
48941     } catch (...) {
48942       {
48943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48944       };
48945     }
48946   }
48947 }
48948
48949
48950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48951   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48952   void (*arg2)() = (void (*)()) 0 ;
48953
48954   arg1 = (Dali::Signal< void () > *)jarg1;
48955   arg2 = (void (*)())jarg2;
48956   {
48957     try {
48958       (arg1)->Disconnect(arg2);
48959     } catch (std::out_of_range& e) {
48960       {
48961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48962       };
48963     } catch (std::exception& e) {
48964       {
48965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48970       };
48971     }
48972   }
48973 }
48974
48975
48976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48977   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48978   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48979   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48980
48981   arg1 = (Dali::Signal< void () > *)jarg1;
48982   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48983   arg3 = (Dali::FunctorDelegate *)jarg3;
48984   {
48985     try {
48986       (arg1)->Connect(arg2,arg3);
48987     } catch (std::out_of_range& e) {
48988       {
48989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48990       };
48991     } catch (std::exception& e) {
48992       {
48993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48994       };
48995     } catch (...) {
48996       {
48997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48998       };
48999     }
49000   }
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
49005   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49006
49007   arg1 = (Dali::Signal< void () > *)jarg1;
49008   {
49009     try {
49010       (arg1)->Emit();
49011     } catch (std::out_of_range& e) {
49012       {
49013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49014       };
49015     } catch (std::exception& e) {
49016       {
49017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49022       };
49023     }
49024   }
49025 }
49026
49027
49028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
49029   unsigned int jresult ;
49030   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49031   bool result;
49032
49033   arg1 = (Dali::Signal< void (float) > *)jarg1;
49034   {
49035     try {
49036       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
49037     } catch (std::out_of_range& e) {
49038       {
49039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49040       };
49041     } catch (std::exception& e) {
49042       {
49043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49044       };
49045     } catch (...) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49048       };
49049     }
49050   }
49051   jresult = result;
49052   return jresult;
49053 }
49054
49055
49056 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
49057   unsigned long jresult ;
49058   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49059   std::size_t result;
49060
49061   arg1 = (Dali::Signal< void (float) > *)jarg1;
49062   {
49063     try {
49064       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (...) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49076       };
49077     }
49078   }
49079   jresult = (unsigned long)result;
49080   return jresult;
49081 }
49082
49083
49084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49086   void (*arg2)(float) = (void (*)(float)) 0 ;
49087
49088   arg1 = (Dali::Signal< void (float) > *)jarg1;
49089   arg2 = (void (*)(float))jarg2;
49090   {
49091     try {
49092       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49093     } catch (std::out_of_range& e) {
49094       {
49095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49096       };
49097     } catch (std::exception& e) {
49098       {
49099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49100       };
49101     } catch (...) {
49102       {
49103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49104       };
49105     }
49106   }
49107 }
49108
49109
49110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49111   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49112   void (*arg2)(float) = (void (*)(float)) 0 ;
49113
49114   arg1 = (Dali::Signal< void (float) > *)jarg1;
49115   arg2 = (void (*)(float))jarg2;
49116   {
49117     try {
49118       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49119     } catch (std::out_of_range& e) {
49120       {
49121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49122       };
49123     } catch (std::exception& e) {
49124       {
49125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49126       };
49127     } catch (...) {
49128       {
49129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49130       };
49131     }
49132   }
49133 }
49134
49135
49136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49137   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49138   float arg2 ;
49139
49140   arg1 = (Dali::Signal< void (float) > *)jarg1;
49141   arg2 = (float)jarg2;
49142   {
49143     try {
49144       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49145     } catch (std::out_of_range& e) {
49146       {
49147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49148       };
49149     } catch (std::exception& e) {
49150       {
49151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (...) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49156       };
49157     }
49158   }
49159 }
49160
49161
49162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49163   void * jresult ;
49164   Dali::Signal< void (float) > *result = 0 ;
49165
49166   {
49167     try {
49168       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49169     } catch (std::out_of_range& e) {
49170       {
49171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (std::exception& e) {
49174       {
49175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49180       };
49181     }
49182   }
49183   jresult = (void *)result;
49184   return jresult;
49185 }
49186
49187
49188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49189   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49190
49191   arg1 = (Dali::Signal< void (float) > *)jarg1;
49192   {
49193     try {
49194       delete arg1;
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49202       };
49203     } catch (...) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49206       };
49207     }
49208   }
49209 }
49210
49211
49212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49213   unsigned int jresult ;
49214   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49215   bool result;
49216
49217   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49218   {
49219     try {
49220       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49221     } catch (std::out_of_range& e) {
49222       {
49223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49224       };
49225     } catch (std::exception& e) {
49226       {
49227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49228       };
49229     } catch (...) {
49230       {
49231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49232       };
49233     }
49234   }
49235   jresult = result;
49236   return jresult;
49237 }
49238
49239
49240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49241   unsigned long jresult ;
49242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49243   std::size_t result;
49244
49245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49246   {
49247     try {
49248       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49249     } catch (std::out_of_range& e) {
49250       {
49251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49252       };
49253     } catch (std::exception& e) {
49254       {
49255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49260       };
49261     }
49262   }
49263   jresult = (unsigned long)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49271
49272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49274   {
49275     try {
49276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49284       };
49285     } catch (...) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49288       };
49289     }
49290   }
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49295   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49296   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49297
49298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49299   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49300   {
49301     try {
49302       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (...) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49314       };
49315     }
49316   }
49317 }
49318
49319
49320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49321   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49322   Dali::BaseHandle arg2 ;
49323   Dali::BaseHandle *argp2 ;
49324
49325   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49326   argp2 = (Dali::BaseHandle *)jarg2;
49327   if (!argp2) {
49328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49329     return ;
49330   }
49331   arg2 = *argp2;
49332   {
49333     try {
49334       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49335     } catch (std::out_of_range& e) {
49336       {
49337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49338       };
49339     } catch (std::exception& e) {
49340       {
49341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (...) {
49344       {
49345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49346       };
49347     }
49348   }
49349 }
49350
49351
49352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49353   void * jresult ;
49354   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49355
49356   {
49357     try {
49358       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49359     } catch (std::out_of_range& e) {
49360       {
49361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (std::exception& e) {
49364       {
49365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49366       };
49367     } catch (...) {
49368       {
49369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49370       };
49371     }
49372   }
49373   jresult = (void *)result;
49374   return jresult;
49375 }
49376
49377
49378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49379   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49380
49381   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49382   {
49383     try {
49384       delete arg1;
49385     } catch (std::out_of_range& e) {
49386       {
49387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49388       };
49389     } catch (std::exception& e) {
49390       {
49391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49396       };
49397     }
49398   }
49399 }
49400
49401
49402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49403   unsigned int jresult ;
49404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49405   bool result;
49406
49407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49408   {
49409     try {
49410       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425   jresult = result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49431   unsigned long jresult ;
49432   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49433   std::size_t result;
49434
49435   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49436   {
49437     try {
49438       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49439     } catch (std::out_of_range& e) {
49440       {
49441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49442       };
49443     } catch (std::exception& e) {
49444       {
49445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (...) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49450       };
49451     }
49452   }
49453   jresult = (unsigned long)result;
49454   return jresult;
49455 }
49456
49457
49458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49459   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49460   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49461
49462   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49463   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49464   {
49465     try {
49466       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49467     } catch (std::out_of_range& e) {
49468       {
49469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49470       };
49471     } catch (std::exception& e) {
49472       {
49473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49474       };
49475     } catch (...) {
49476       {
49477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49478       };
49479     }
49480   }
49481 }
49482
49483
49484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49485   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49486   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49487
49488   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49489   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49490   {
49491     try {
49492       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49500       };
49501     } catch (...) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49504       };
49505     }
49506   }
49507 }
49508
49509
49510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49511   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49512   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49513
49514   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49515   arg2 = (Dali::RefObject *)jarg2;
49516   {
49517     try {
49518       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49519     } catch (std::out_of_range& e) {
49520       {
49521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49522       };
49523     } catch (std::exception& e) {
49524       {
49525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49530       };
49531     }
49532   }
49533 }
49534
49535
49536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49537   void * jresult ;
49538   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49539
49540   {
49541     try {
49542       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49554       };
49555     }
49556   }
49557   jresult = (void *)result;
49558   return jresult;
49559 }
49560
49561
49562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49563   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49564
49565   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49566   {
49567     try {
49568       delete arg1;
49569     } catch (std::out_of_range& e) {
49570       {
49571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49572       };
49573     } catch (std::exception& e) {
49574       {
49575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49576       };
49577     } catch (...) {
49578       {
49579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49580       };
49581     }
49582   }
49583 }
49584
49585
49586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49587   unsigned int jresult ;
49588   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49589   bool result;
49590
49591   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49592   {
49593     try {
49594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49595     } catch (std::out_of_range& e) {
49596       {
49597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49598       };
49599     } catch (std::exception& e) {
49600       {
49601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49602       };
49603     } catch (...) {
49604       {
49605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49606       };
49607     }
49608   }
49609   jresult = result;
49610   return jresult;
49611 }
49612
49613
49614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49615   unsigned long jresult ;
49616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49617   std::size_t result;
49618
49619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49620   {
49621     try {
49622       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49623     } catch (std::out_of_range& e) {
49624       {
49625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (std::exception& e) {
49628       {
49629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637   jresult = (unsigned long)result;
49638   return jresult;
49639 }
49640
49641
49642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49643   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49644   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49645
49646   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49647   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49648   {
49649     try {
49650       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49651     } catch (std::out_of_range& e) {
49652       {
49653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49654       };
49655     } catch (std::exception& e) {
49656       {
49657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49658       };
49659     } catch (...) {
49660       {
49661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49662       };
49663     }
49664   }
49665 }
49666
49667
49668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49669   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49670   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49671
49672   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49673   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49674   {
49675     try {
49676       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691 }
49692
49693
49694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49695   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49696   Dali::PropertyNotification *arg2 = 0 ;
49697
49698   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49699   arg2 = (Dali::PropertyNotification *)jarg2;
49700   if (!arg2) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49702     return ;
49703   }
49704   {
49705     try {
49706       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49707     } catch (std::out_of_range& e) {
49708       {
49709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49710       };
49711     } catch (std::exception& e) {
49712       {
49713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (...) {
49716       {
49717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49718       };
49719     }
49720   }
49721 }
49722
49723
49724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49725   void * jresult ;
49726   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49727
49728   {
49729     try {
49730       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49731     } catch (std::out_of_range& e) {
49732       {
49733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (std::exception& e) {
49736       {
49737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (...) {
49740       {
49741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49742       };
49743     }
49744   }
49745   jresult = (void *)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49751   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49752
49753   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49754   {
49755     try {
49756       delete arg1;
49757     } catch (std::out_of_range& e) {
49758       {
49759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49760       };
49761     } catch (std::exception& e) {
49762       {
49763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (...) {
49766       {
49767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49768       };
49769     }
49770   }
49771 }
49772
49773
49774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49775   unsigned int jresult ;
49776   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49777   bool result;
49778
49779   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49780   {
49781     try {
49782       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (...) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49794       };
49795     }
49796   }
49797   jresult = result;
49798   return jresult;
49799 }
49800
49801
49802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49803   unsigned long jresult ;
49804   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49805   std::size_t result;
49806
49807   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49808   {
49809     try {
49810       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (...) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49822       };
49823     }
49824   }
49825   jresult = (unsigned long)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49831   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49832   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49833
49834   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49835   arg2 = (void (*)(Dali::Image))jarg2;
49836   {
49837     try {
49838       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49839     } catch (std::out_of_range& e) {
49840       {
49841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49842       };
49843     } catch (std::exception& e) {
49844       {
49845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (...) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49850       };
49851     }
49852   }
49853 }
49854
49855
49856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49857   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49858   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49859
49860   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49861   arg2 = (void (*)(Dali::Image))jarg2;
49862   {
49863     try {
49864       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49865     } catch (std::out_of_range& e) {
49866       {
49867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49868       };
49869     } catch (std::exception& e) {
49870       {
49871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (...) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49876       };
49877     }
49878   }
49879 }
49880
49881
49882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49883   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49884   Dali::Image arg2 ;
49885   Dali::Image *argp2 ;
49886
49887   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49888   argp2 = (Dali::Image *)jarg2;
49889   if (!argp2) {
49890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49891     return ;
49892   }
49893   arg2 = *argp2;
49894   {
49895     try {
49896       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49897     } catch (std::out_of_range& e) {
49898       {
49899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49900       };
49901     } catch (std::exception& e) {
49902       {
49903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49904       };
49905     } catch (...) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49908       };
49909     }
49910   }
49911 }
49912
49913
49914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49915   void * jresult ;
49916   Dali::Signal< void (Dali::Image) > *result = 0 ;
49917
49918   {
49919     try {
49920       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49921     } catch (std::out_of_range& e) {
49922       {
49923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49924       };
49925     } catch (std::exception& e) {
49926       {
49927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49932       };
49933     }
49934   }
49935   jresult = (void *)result;
49936   return jresult;
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49941   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49942
49943   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49944   {
49945     try {
49946       delete arg1;
49947     } catch (std::out_of_range& e) {
49948       {
49949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49950       };
49951     } catch (std::exception& e) {
49952       {
49953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49954       };
49955     } catch (...) {
49956       {
49957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49958       };
49959     }
49960   }
49961 }
49962
49963
49964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49965   void * jresult ;
49966   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49967
49968   {
49969     try {
49970       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49971     } catch (std::out_of_range& e) {
49972       {
49973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (std::exception& e) {
49976       {
49977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49982       };
49983     }
49984   }
49985   jresult = (void *)result;
49986   return jresult;
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49991   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49992
49993   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49994   {
49995     try {
49996       delete arg1;
49997     } catch (std::out_of_range& e) {
49998       {
49999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (std::exception& e) {
50002       {
50003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011 }
50012
50013
50014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
50015   unsigned int jresult ;
50016   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50017   bool result;
50018
50019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50020   {
50021     try {
50022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
50023     } catch (std::out_of_range& e) {
50024       {
50025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50026       };
50027     } catch (std::exception& e) {
50028       {
50029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (...) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50034       };
50035     }
50036   }
50037   jresult = result;
50038   return jresult;
50039 }
50040
50041
50042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50043   unsigned long jresult ;
50044   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50045   std::size_t result;
50046
50047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50048   {
50049     try {
50050       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50058       };
50059     } catch (...) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50062       };
50063     }
50064   }
50065   jresult = (unsigned long)result;
50066   return jresult;
50067 }
50068
50069
50070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50071   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50072   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50073
50074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50075   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50076   {
50077     try {
50078       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (...) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50090       };
50091     }
50092   }
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50097   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50098   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50099
50100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50101   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50102   {
50103     try {
50104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50105     } catch (std::out_of_range& e) {
50106       {
50107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50108       };
50109     } catch (std::exception& e) {
50110       {
50111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50116       };
50117     }
50118   }
50119 }
50120
50121
50122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50123   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50124   Dali::Actor arg2 ;
50125   Dali::LongPressGesture *arg3 = 0 ;
50126   Dali::Actor *argp2 ;
50127
50128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50129   argp2 = (Dali::Actor *)jarg2;
50130   if (!argp2) {
50131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50132     return ;
50133   }
50134   arg2 = *argp2;
50135   arg3 = (Dali::LongPressGesture *)jarg3;
50136   if (!arg3) {
50137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50138     return ;
50139   }
50140   {
50141     try {
50142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50143     } catch (std::out_of_range& e) {
50144       {
50145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50146       };
50147     } catch (std::exception& e) {
50148       {
50149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50150       };
50151     } catch (...) {
50152       {
50153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50154       };
50155     }
50156   }
50157 }
50158
50159
50160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50161   void * jresult ;
50162   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50163
50164   {
50165     try {
50166       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (...) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50178       };
50179     }
50180   }
50181   jresult = (void *)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50187   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50188
50189   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50190   {
50191     try {
50192       delete arg1;
50193     } catch (std::out_of_range& e) {
50194       {
50195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50196       };
50197     } catch (std::exception& e) {
50198       {
50199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50200       };
50201     } catch (...) {
50202       {
50203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50204       };
50205     }
50206   }
50207 }
50208
50209
50210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50211   unsigned int jresult ;
50212   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50213   bool result;
50214
50215   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50216   {
50217     try {
50218       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
50219     } catch (std::out_of_range& e) {
50220       {
50221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50222       };
50223     } catch (std::exception& e) {
50224       {
50225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50226       };
50227     } catch (...) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50230       };
50231     }
50232   }
50233   jresult = result;
50234   return jresult;
50235 }
50236
50237
50238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50239   unsigned long jresult ;
50240   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50241   std::size_t result;
50242
50243   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50244   {
50245     try {
50246       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (...) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50258       };
50259     }
50260   }
50261   jresult = (unsigned long)result;
50262   return jresult;
50263 }
50264
50265
50266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50267   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50268   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50269
50270   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50271   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50272   {
50273     try {
50274       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50275     } catch (std::out_of_range& e) {
50276       {
50277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50278       };
50279     } catch (std::exception& e) {
50280       {
50281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50282       };
50283     } catch (...) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50286       };
50287     }
50288   }
50289 }
50290
50291
50292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50293   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50294   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50295
50296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50297   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50298   {
50299     try {
50300       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50301     } catch (std::out_of_range& e) {
50302       {
50303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50304       };
50305     } catch (std::exception& e) {
50306       {
50307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50312       };
50313     }
50314   }
50315 }
50316
50317
50318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50319   unsigned int jresult ;
50320   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50321   Dali::Actor arg2 ;
50322   Dali::TouchData *arg3 = 0 ;
50323   Dali::Actor *argp2 ;
50324   bool result;
50325
50326   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50327   argp2 = (Dali::Actor *)jarg2;
50328   if (!argp2) {
50329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50330     return 0;
50331   }
50332   arg2 = *argp2;
50333   arg3 = (Dali::TouchData *)jarg3;
50334   if (!arg3) {
50335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50336     return 0;
50337   }
50338   {
50339     try {
50340       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50341     } catch (std::out_of_range& e) {
50342       {
50343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (std::exception& e) {
50346       {
50347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355   jresult = result;
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50361   void * jresult ;
50362   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50363
50364   {
50365     try {
50366       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381   jresult = (void *)result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50387   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50388
50389   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50390   {
50391     try {
50392       delete arg1;
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50400       };
50401     } catch (...) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50404       };
50405     }
50406   }
50407 }
50408
50409
50410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50411   unsigned int jresult ;
50412   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50413   bool result;
50414
50415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50416   {
50417     try {
50418       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
50419     } catch (std::out_of_range& e) {
50420       {
50421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50422       };
50423     } catch (std::exception& e) {
50424       {
50425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50426       };
50427     } catch (...) {
50428       {
50429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50430       };
50431     }
50432   }
50433   jresult = result;
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50439   unsigned long jresult ;
50440   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50441   std::size_t result;
50442
50443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50444   {
50445     try {
50446       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (...) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50458       };
50459     }
50460   }
50461   jresult = (unsigned long)result;
50462   return jresult;
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50467   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50468   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50469
50470   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50471   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50472   {
50473     try {
50474       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50475     } catch (std::out_of_range& e) {
50476       {
50477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50478       };
50479     } catch (std::exception& e) {
50480       {
50481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (...) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50486       };
50487     }
50488   }
50489 }
50490
50491
50492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50493   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50494   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50495
50496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50497   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50498   {
50499     try {
50500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50501     } catch (std::out_of_range& e) {
50502       {
50503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50504       };
50505     } catch (std::exception& e) {
50506       {
50507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50508       };
50509     } catch (...) {
50510       {
50511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50512       };
50513     }
50514   }
50515 }
50516
50517
50518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50519   unsigned int jresult ;
50520   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50521   Dali::Actor arg2 ;
50522   Dali::HoverEvent *arg3 = 0 ;
50523   Dali::Actor *argp2 ;
50524   bool result;
50525
50526   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50527   argp2 = (Dali::Actor *)jarg2;
50528   if (!argp2) {
50529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50530     return 0;
50531   }
50532   arg2 = *argp2;
50533   arg3 = (Dali::HoverEvent *)jarg3;
50534   if (!arg3) {
50535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50536     return 0;
50537   }
50538   {
50539     try {
50540       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50541     } catch (std::out_of_range& e) {
50542       {
50543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (std::exception& e) {
50546       {
50547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50561   void * jresult ;
50562   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50563
50564   {
50565     try {
50566       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50567     } catch (std::out_of_range& e) {
50568       {
50569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (std::exception& e) {
50572       {
50573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (...) {
50576       {
50577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50578       };
50579     }
50580   }
50581   jresult = (void *)result;
50582   return jresult;
50583 }
50584
50585
50586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50587   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50588
50589   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50590   {
50591     try {
50592       delete arg1;
50593     } catch (std::out_of_range& e) {
50594       {
50595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50596       };
50597     } catch (std::exception& e) {
50598       {
50599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50600       };
50601     } catch (...) {
50602       {
50603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50604       };
50605     }
50606   }
50607 }
50608
50609
50610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50611   unsigned int jresult ;
50612   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50613   bool result;
50614
50615   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50616   {
50617     try {
50618       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50630       };
50631     }
50632   }
50633   jresult = result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50639   unsigned long jresult ;
50640   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50641   std::size_t result;
50642
50643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50644   {
50645     try {
50646       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
50647     } catch (std::out_of_range& e) {
50648       {
50649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50650       };
50651     } catch (std::exception& e) {
50652       {
50653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50654       };
50655     } catch (...) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50658       };
50659     }
50660   }
50661   jresult = (unsigned long)result;
50662   return jresult;
50663 }
50664
50665
50666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50667   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50668   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50669
50670   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50671   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50672   {
50673     try {
50674       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50675     } catch (std::out_of_range& e) {
50676       {
50677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50678       };
50679     } catch (std::exception& e) {
50680       {
50681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (...) {
50684       {
50685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50686       };
50687     }
50688   }
50689 }
50690
50691
50692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50693   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50694   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50695
50696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50697   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50698   {
50699     try {
50700       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50701     } catch (std::out_of_range& e) {
50702       {
50703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (std::exception& e) {
50706       {
50707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50708       };
50709     } catch (...) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50712       };
50713     }
50714   }
50715 }
50716
50717
50718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50719   unsigned int jresult ;
50720   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50721   Dali::Actor arg2 ;
50722   Dali::WheelEvent *arg3 = 0 ;
50723   Dali::Actor *argp2 ;
50724   bool result;
50725
50726   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50727   argp2 = (Dali::Actor *)jarg2;
50728   if (!argp2) {
50729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50730     return 0;
50731   }
50732   arg2 = *argp2;
50733   arg3 = (Dali::WheelEvent *)jarg3;
50734   if (!arg3) {
50735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50736     return 0;
50737   }
50738   {
50739     try {
50740       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50741     } catch (std::out_of_range& e) {
50742       {
50743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50744       };
50745     } catch (std::exception& e) {
50746       {
50747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50748       };
50749     } catch (...) {
50750       {
50751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50752       };
50753     }
50754   }
50755   jresult = result;
50756   return jresult;
50757 }
50758
50759
50760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50761   void * jresult ;
50762   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50763
50764   {
50765     try {
50766       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (...) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50778       };
50779     }
50780   }
50781   jresult = (void *)result;
50782   return jresult;
50783 }
50784
50785
50786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50787   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50788
50789   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50790   {
50791     try {
50792       delete arg1;
50793     } catch (std::out_of_range& e) {
50794       {
50795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (std::exception& e) {
50798       {
50799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50800       };
50801     } catch (...) {
50802       {
50803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50804       };
50805     }
50806   }
50807 }
50808
50809
50810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50811   unsigned int jresult ;
50812   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50813   bool result;
50814
50815   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50816   {
50817     try {
50818       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50819     } catch (std::out_of_range& e) {
50820       {
50821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (std::exception& e) {
50824       {
50825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50826       };
50827     } catch (...) {
50828       {
50829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50830       };
50831     }
50832   }
50833   jresult = result;
50834   return jresult;
50835 }
50836
50837
50838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50839   unsigned long jresult ;
50840   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50841   std::size_t result;
50842
50843   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50844   {
50845     try {
50846       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50847     } catch (std::out_of_range& e) {
50848       {
50849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (std::exception& e) {
50852       {
50853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861   jresult = (unsigned long)result;
50862   return jresult;
50863 }
50864
50865
50866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50867   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50868   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50869
50870   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50871   arg2 = (void (*)(Dali::Actor))jarg2;
50872   {
50873     try {
50874       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50875     } catch (std::out_of_range& e) {
50876       {
50877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50878       };
50879     } catch (std::exception& e) {
50880       {
50881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50882       };
50883     } catch (...) {
50884       {
50885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50886       };
50887     }
50888   }
50889 }
50890
50891
50892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50894   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50897   arg2 = (void (*)(Dali::Actor))jarg2;
50898   {
50899     try {
50900       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50908       };
50909     } catch (...) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50912       };
50913     }
50914   }
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50919   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50920   Dali::Actor arg2 ;
50921   Dali::Actor *argp2 ;
50922
50923   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50924   argp2 = (Dali::Actor *)jarg2;
50925   if (!argp2) {
50926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50927     return ;
50928   }
50929   arg2 = *argp2;
50930   {
50931     try {
50932       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50933     } catch (std::out_of_range& e) {
50934       {
50935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50936       };
50937     } catch (std::exception& e) {
50938       {
50939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50940       };
50941     } catch (...) {
50942       {
50943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50944       };
50945     }
50946   }
50947 }
50948
50949
50950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50951   void * jresult ;
50952   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50953
50954   {
50955     try {
50956       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (...) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50968       };
50969     }
50970   }
50971   jresult = (void *)result;
50972   return jresult;
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50977   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50978
50979   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50980   {
50981     try {
50982       delete arg1;
50983     } catch (std::out_of_range& e) {
50984       {
50985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50986       };
50987     } catch (std::exception& e) {
50988       {
50989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50990       };
50991     } catch (...) {
50992       {
50993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50994       };
50995     }
50996   }
50997 }
50998
50999
51000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
51001   unsigned int jresult ;
51002   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51003   bool result;
51004
51005   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51006   {
51007     try {
51008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51009     } catch (std::out_of_range& e) {
51010       {
51011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (std::exception& e) {
51014       {
51015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (...) {
51018       {
51019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51020       };
51021     }
51022   }
51023   jresult = result;
51024   return jresult;
51025 }
51026
51027
51028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
51029   unsigned long jresult ;
51030   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51031   std::size_t result;
51032
51033   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51034   {
51035     try {
51036       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51044       };
51045     } catch (...) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51048       };
51049     }
51050   }
51051   jresult = (unsigned long)result;
51052   return jresult;
51053 }
51054
51055
51056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
51057   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51058   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51059
51060   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51061   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51062   {
51063     try {
51064       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51076       };
51077     }
51078   }
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51083   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51084   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51085
51086   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51087   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51088   {
51089     try {
51090       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51091     } catch (std::out_of_range& e) {
51092       {
51093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51094       };
51095     } catch (std::exception& e) {
51096       {
51097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (...) {
51100       {
51101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51102       };
51103     }
51104   }
51105 }
51106
51107
51108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51109   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51110   Dali::KeyEvent *arg2 = 0 ;
51111
51112   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51113   arg2 = (Dali::KeyEvent *)jarg2;
51114   if (!arg2) {
51115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51116     return ;
51117   }
51118   {
51119     try {
51120       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51128       };
51129     } catch (...) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51132       };
51133     }
51134   }
51135 }
51136
51137
51138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51139   void * jresult ;
51140   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51141
51142   {
51143     try {
51144       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51145     } catch (std::out_of_range& e) {
51146       {
51147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (std::exception& e) {
51150       {
51151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51156       };
51157     }
51158   }
51159   jresult = (void *)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51165   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51166
51167   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51168   {
51169     try {
51170       delete arg1;
51171     } catch (std::out_of_range& e) {
51172       {
51173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51174       };
51175     } catch (std::exception& e) {
51176       {
51177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51182       };
51183     }
51184   }
51185 }
51186
51187
51188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51189   unsigned int jresult ;
51190   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51191   bool result;
51192
51193   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51194   {
51195     try {
51196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51197     } catch (std::out_of_range& e) {
51198       {
51199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (std::exception& e) {
51202       {
51203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211   jresult = result;
51212   return jresult;
51213 }
51214
51215
51216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51217   unsigned long jresult ;
51218   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51219   std::size_t result;
51220
51221   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51222   {
51223     try {
51224       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51236       };
51237     }
51238   }
51239   jresult = (unsigned long)result;
51240   return jresult;
51241 }
51242
51243
51244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51245   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51246   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51247
51248   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51249   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51250   {
51251     try {
51252       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51253     } catch (std::out_of_range& e) {
51254       {
51255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51256       };
51257     } catch (std::exception& e) {
51258       {
51259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51260       };
51261     } catch (...) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51264       };
51265     }
51266   }
51267 }
51268
51269
51270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51271   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51272   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51273
51274   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51275   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51276   {
51277     try {
51278       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293 }
51294
51295
51296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51297   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51298   Dali::TouchData *arg2 = 0 ;
51299
51300   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51301   arg2 = (Dali::TouchData *)jarg2;
51302   if (!arg2) {
51303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51304     return ;
51305   }
51306   {
51307     try {
51308       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51309     } catch (std::out_of_range& e) {
51310       {
51311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (std::exception& e) {
51314       {
51315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51320       };
51321     }
51322   }
51323 }
51324
51325
51326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51327   void * jresult ;
51328   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51329
51330   {
51331     try {
51332       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (...) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51344       };
51345     }
51346   }
51347   jresult = (void *)result;
51348   return jresult;
51349 }
51350
51351
51352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51353   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51354
51355   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51356   {
51357     try {
51358       delete arg1;
51359     } catch (std::out_of_range& e) {
51360       {
51361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51362       };
51363     } catch (std::exception& e) {
51364       {
51365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51366       };
51367     } catch (...) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51370       };
51371     }
51372   }
51373 }
51374
51375
51376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51377   unsigned int jresult ;
51378   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51379   bool result;
51380
51381   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51382   {
51383     try {
51384       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51385     } catch (std::out_of_range& e) {
51386       {
51387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51388       };
51389     } catch (std::exception& e) {
51390       {
51391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51392       };
51393     } catch (...) {
51394       {
51395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51396       };
51397     }
51398   }
51399   jresult = result;
51400   return jresult;
51401 }
51402
51403
51404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51405   unsigned long jresult ;
51406   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51407   std::size_t result;
51408
51409   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51410   {
51411     try {
51412       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51413     } catch (std::out_of_range& e) {
51414       {
51415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51416       };
51417     } catch (std::exception& e) {
51418       {
51419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51424       };
51425     }
51426   }
51427   jresult = (unsigned long)result;
51428   return jresult;
51429 }
51430
51431
51432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51433   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51434   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51435
51436   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51437   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51438   {
51439     try {
51440       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51452       };
51453     }
51454   }
51455 }
51456
51457
51458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51459   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51460   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51461
51462   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51463   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51464   {
51465     try {
51466       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51467     } catch (std::out_of_range& e) {
51468       {
51469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (std::exception& e) {
51472       {
51473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481 }
51482
51483
51484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51485   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51486   Dali::WheelEvent *arg2 = 0 ;
51487
51488   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51489   arg2 = (Dali::WheelEvent *)jarg2;
51490   if (!arg2) {
51491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51492     return ;
51493   }
51494   {
51495     try {
51496       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51497     } catch (std::out_of_range& e) {
51498       {
51499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (std::exception& e) {
51502       {
51503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511 }
51512
51513
51514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51515   void * jresult ;
51516   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51517
51518   {
51519     try {
51520       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51532       };
51533     }
51534   }
51535   jresult = (void *)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51541   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51542
51543   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51544   {
51545     try {
51546       delete arg1;
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51558       };
51559     }
51560   }
51561 }
51562
51563
51564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51565   void * jresult ;
51566   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51567
51568   {
51569     try {
51570       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51571     } catch (std::out_of_range& e) {
51572       {
51573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (std::exception& e) {
51576       {
51577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51578       };
51579     } catch (...) {
51580       {
51581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51582       };
51583     }
51584   }
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51591   void * jresult ;
51592   Dali::Radian arg1 ;
51593   Dali::Radian arg2 ;
51594   Dali::Radian *argp1 ;
51595   Dali::Radian *argp2 ;
51596   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51597
51598   argp1 = (Dali::Radian *)jarg1;
51599   if (!argp1) {
51600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51601     return 0;
51602   }
51603   arg1 = *argp1;
51604   argp2 = (Dali::Radian *)jarg2;
51605   if (!argp2) {
51606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51607     return 0;
51608   }
51609   arg2 = *argp2;
51610   {
51611     try {
51612       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (...) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51624       };
51625     }
51626   }
51627   jresult = (void *)result;
51628   return jresult;
51629 }
51630
51631
51632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51633   void * jresult ;
51634   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51635   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51636
51637   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51638   if (!arg1) {
51639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51640     return 0;
51641   }
51642   {
51643     try {
51644       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51645     } catch (std::out_of_range& e) {
51646       {
51647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (std::exception& e) {
51650       {
51651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659   jresult = (void *)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51665   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51666   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51667
51668   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51669   arg2 = (Dali::Radian *)jarg2;
51670   if (arg1) (arg1)->first = *arg2;
51671 }
51672
51673
51674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51675   void * jresult ;
51676   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51677   Dali::Radian *result = 0 ;
51678
51679   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51680   result = (Dali::Radian *)& ((arg1)->first);
51681   jresult = (void *)result;
51682   return jresult;
51683 }
51684
51685
51686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51687   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51688   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51689
51690   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51691   arg2 = (Dali::Radian *)jarg2;
51692   if (arg1) (arg1)->second = *arg2;
51693 }
51694
51695
51696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51697   void * jresult ;
51698   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51699   Dali::Radian *result = 0 ;
51700
51701   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51702   result = (Dali::Radian *)& ((arg1)->second);
51703   jresult = (void *)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51709   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51710
51711   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51712   {
51713     try {
51714       delete arg1;
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51722       };
51723     } catch (...) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51726       };
51727     }
51728   }
51729 }
51730
51731
51732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51733   unsigned int jresult ;
51734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51735   bool result;
51736
51737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51738   {
51739     try {
51740       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
51741     } catch (std::out_of_range& e) {
51742       {
51743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51744       };
51745     } catch (std::exception& e) {
51746       {
51747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (...) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51752       };
51753     }
51754   }
51755   jresult = result;
51756   return jresult;
51757 }
51758
51759
51760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51761   unsigned long jresult ;
51762   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51763   std::size_t result;
51764
51765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51766   {
51767     try {
51768       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
51769     } catch (std::out_of_range& e) {
51770       {
51771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51772       };
51773     } catch (std::exception& e) {
51774       {
51775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51776       };
51777     } catch (...) {
51778       {
51779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51780       };
51781     }
51782   }
51783   jresult = (unsigned long)result;
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51789   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51790   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51791
51792   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51793   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51794   {
51795     try {
51796       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51797     } catch (std::out_of_range& e) {
51798       {
51799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51800       };
51801     } catch (std::exception& e) {
51802       {
51803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (...) {
51806       {
51807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51808       };
51809     }
51810   }
51811 }
51812
51813
51814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51815   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51816   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51817
51818   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51819   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51820   {
51821     try {
51822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51823     } catch (std::out_of_range& e) {
51824       {
51825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51826       };
51827     } catch (std::exception& e) {
51828       {
51829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51834       };
51835     }
51836   }
51837 }
51838
51839
51840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51841   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51842   Dali::Actor arg2 ;
51843   Dali::PanGesture *arg3 = 0 ;
51844   Dali::Actor *argp2 ;
51845
51846   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51847   argp2 = (Dali::Actor *)jarg2;
51848   if (!argp2) {
51849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51850     return ;
51851   }
51852   arg2 = *argp2;
51853   arg3 = (Dali::PanGesture *)jarg3;
51854   if (!arg3) {
51855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51856     return ;
51857   }
51858   {
51859     try {
51860       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51861     } catch (std::out_of_range& e) {
51862       {
51863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51864       };
51865     } catch (std::exception& e) {
51866       {
51867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51868       };
51869     } catch (...) {
51870       {
51871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51872       };
51873     }
51874   }
51875 }
51876
51877
51878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51879   void * jresult ;
51880   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51881
51882   {
51883     try {
51884       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (void *)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51905   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51906
51907   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51908   {
51909     try {
51910       delete arg1;
51911     } catch (std::out_of_range& e) {
51912       {
51913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51914       };
51915     } catch (std::exception& e) {
51916       {
51917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (...) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51922       };
51923     }
51924   }
51925 }
51926
51927
51928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51929   unsigned int jresult ;
51930   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51931   bool result;
51932
51933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51934   {
51935     try {
51936       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
51937     } catch (std::out_of_range& e) {
51938       {
51939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51940       };
51941     } catch (std::exception& e) {
51942       {
51943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (...) {
51946       {
51947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51948       };
51949     }
51950   }
51951   jresult = result;
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51957   unsigned long jresult ;
51958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51959   std::size_t result;
51960
51961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51962   {
51963     try {
51964       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51972       };
51973     } catch (...) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51976       };
51977     }
51978   }
51979   jresult = (unsigned long)result;
51980   return jresult;
51981 }
51982
51983
51984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51985   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51986   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51987
51988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51989   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51990   {
51991     try {
51992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007 }
52008
52009
52010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52011   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52012   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
52013
52014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52015   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
52016   {
52017     try {
52018       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52030       };
52031     }
52032   }
52033 }
52034
52035
52036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52037   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52038   Dali::Actor arg2 ;
52039   Dali::PinchGesture *arg3 = 0 ;
52040   Dali::Actor *argp2 ;
52041
52042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52043   argp2 = (Dali::Actor *)jarg2;
52044   if (!argp2) {
52045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52046     return ;
52047   }
52048   arg2 = *argp2;
52049   arg3 = (Dali::PinchGesture *)jarg3;
52050   if (!arg3) {
52051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
52052     return ;
52053   }
52054   {
52055     try {
52056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
52057     } catch (std::out_of_range& e) {
52058       {
52059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (std::exception& e) {
52062       {
52063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (...) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52068       };
52069     }
52070   }
52071 }
52072
52073
52074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
52075   void * jresult ;
52076   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
52077
52078   {
52079     try {
52080       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095   jresult = (void *)result;
52096   return jresult;
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52101   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52102
52103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52104   {
52105     try {
52106       delete arg1;
52107     } catch (std::out_of_range& e) {
52108       {
52109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52110       };
52111     } catch (std::exception& e) {
52112       {
52113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52114       };
52115     } catch (...) {
52116       {
52117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52118       };
52119     }
52120   }
52121 }
52122
52123
52124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52125   unsigned int jresult ;
52126   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52127   bool result;
52128
52129   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52130   {
52131     try {
52132       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
52133     } catch (std::out_of_range& e) {
52134       {
52135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52136       };
52137     } catch (std::exception& e) {
52138       {
52139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52140       };
52141     } catch (...) {
52142       {
52143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52144       };
52145     }
52146   }
52147   jresult = result;
52148   return jresult;
52149 }
52150
52151
52152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52153   unsigned long jresult ;
52154   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52155   std::size_t result;
52156
52157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52158   {
52159     try {
52160       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
52161     } catch (std::out_of_range& e) {
52162       {
52163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52164       };
52165     } catch (std::exception& e) {
52166       {
52167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52168       };
52169     } catch (...) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52172       };
52173     }
52174   }
52175   jresult = (unsigned long)result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52181   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52182   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52183
52184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52185   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52186   {
52187     try {
52188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52200       };
52201     }
52202   }
52203 }
52204
52205
52206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52207   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52208   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52209
52210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52211   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52212   {
52213     try {
52214       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (...) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52226       };
52227     }
52228   }
52229 }
52230
52231
52232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52233   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52234   Dali::Actor arg2 ;
52235   Dali::TapGesture *arg3 = 0 ;
52236   Dali::Actor *argp2 ;
52237
52238   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52239   argp2 = (Dali::Actor *)jarg2;
52240   if (!argp2) {
52241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52242     return ;
52243   }
52244   arg2 = *argp2;
52245   arg3 = (Dali::TapGesture *)jarg3;
52246   if (!arg3) {
52247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52248     return ;
52249   }
52250   {
52251     try {
52252       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52264       };
52265     }
52266   }
52267 }
52268
52269
52270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52271   void * jresult ;
52272   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52273
52274   {
52275     try {
52276       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52277     } catch (std::out_of_range& e) {
52278       {
52279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52280       };
52281     } catch (std::exception& e) {
52282       {
52283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52284       };
52285     } catch (...) {
52286       {
52287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52288       };
52289     }
52290   }
52291   jresult = (void *)result;
52292   return jresult;
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52297   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52298
52299   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52300   {
52301     try {
52302       delete arg1;
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52310       };
52311     } catch (...) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52314       };
52315     }
52316   }
52317 }
52318
52319
52320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52321   unsigned int jresult ;
52322   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52323   bool result;
52324
52325   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52326   {
52327     try {
52328       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343   jresult = result;
52344   return jresult;
52345 }
52346
52347
52348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52349   unsigned long jresult ;
52350   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52351   std::size_t result;
52352
52353   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52354   {
52355     try {
52356       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52368       };
52369     }
52370   }
52371   jresult = (unsigned long)result;
52372   return jresult;
52373 }
52374
52375
52376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52377   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52378   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52379
52380   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52381   arg2 = (void (*)(Dali::Animation &))jarg2;
52382   {
52383     try {
52384       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52392       };
52393     } catch (...) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52396       };
52397     }
52398   }
52399 }
52400
52401
52402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52403   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52404   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52405
52406   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52407   arg2 = (void (*)(Dali::Animation &))jarg2;
52408   {
52409     try {
52410       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52418       };
52419     } catch (...) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52422       };
52423     }
52424   }
52425 }
52426
52427
52428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52429   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52430   Dali::Animation *arg2 = 0 ;
52431
52432   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52433   arg2 = (Dali::Animation *)jarg2;
52434   if (!arg2) {
52435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52436     return ;
52437   }
52438   {
52439     try {
52440       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52441     } catch (std::out_of_range& e) {
52442       {
52443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52444       };
52445     } catch (std::exception& e) {
52446       {
52447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (...) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52452       };
52453     }
52454   }
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52459   void * jresult ;
52460   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52461
52462   {
52463     try {
52464       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52465     } catch (std::out_of_range& e) {
52466       {
52467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (std::exception& e) {
52470       {
52471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52472       };
52473     } catch (...) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52476       };
52477     }
52478   }
52479   jresult = (void *)result;
52480   return jresult;
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52485   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52486
52487   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52488   {
52489     try {
52490       delete arg1;
52491     } catch (std::out_of_range& e) {
52492       {
52493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52494       };
52495     } catch (std::exception& e) {
52496       {
52497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52498       };
52499     } catch (...) {
52500       {
52501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52502       };
52503     }
52504   }
52505 }
52506
52507
52508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52509   unsigned int jresult ;
52510   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52511   bool result;
52512
52513   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52514   {
52515     try {
52516       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52524       };
52525     } catch (...) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52528       };
52529     }
52530   }
52531   jresult = result;
52532   return jresult;
52533 }
52534
52535
52536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52537   unsigned long jresult ;
52538   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52539   std::size_t result;
52540
52541   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52542   {
52543     try {
52544       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52545     } catch (std::out_of_range& e) {
52546       {
52547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52548       };
52549     } catch (std::exception& e) {
52550       {
52551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (...) {
52554       {
52555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52556       };
52557     }
52558   }
52559   jresult = (unsigned long)result;
52560   return jresult;
52561 }
52562
52563
52564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52565   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52566   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52567
52568   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52569   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52570   {
52571     try {
52572       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52573     } catch (std::out_of_range& e) {
52574       {
52575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52576       };
52577     } catch (std::exception& e) {
52578       {
52579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52584       };
52585     }
52586   }
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52591   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52592   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52593
52594   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52595   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52596   {
52597     try {
52598       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52599     } catch (std::out_of_range& e) {
52600       {
52601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52602       };
52603     } catch (std::exception& e) {
52604       {
52605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52610       };
52611     }
52612   }
52613 }
52614
52615
52616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52617   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52618   Dali::ResourceImage arg2 ;
52619   Dali::ResourceImage *argp2 ;
52620
52621   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52622   argp2 = (Dali::ResourceImage *)jarg2;
52623   if (!argp2) {
52624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52625     return ;
52626   }
52627   arg2 = *argp2;
52628   {
52629     try {
52630       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52631     } catch (std::out_of_range& e) {
52632       {
52633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52634       };
52635     } catch (std::exception& e) {
52636       {
52637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (...) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52642       };
52643     }
52644   }
52645 }
52646
52647
52648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52649   void * jresult ;
52650   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52651
52652   {
52653     try {
52654       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52655     } catch (std::out_of_range& e) {
52656       {
52657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (std::exception& e) {
52660       {
52661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (...) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52666       };
52667     }
52668   }
52669   jresult = (void *)result;
52670   return jresult;
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52675   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52676
52677   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52678   {
52679     try {
52680       delete arg1;
52681     } catch (std::out_of_range& e) {
52682       {
52683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52684       };
52685     } catch (std::exception& e) {
52686       {
52687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52688       };
52689     } catch (...) {
52690       {
52691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52692       };
52693     }
52694   }
52695 }
52696
52697
52698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52699   unsigned int jresult ;
52700   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52701   bool result;
52702
52703   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52704   {
52705     try {
52706       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52707     } catch (std::out_of_range& e) {
52708       {
52709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52710       };
52711     } catch (std::exception& e) {
52712       {
52713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (...) {
52716       {
52717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52718       };
52719     }
52720   }
52721   jresult = result;
52722   return jresult;
52723 }
52724
52725
52726 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52727   unsigned long jresult ;
52728   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52729   std::size_t result;
52730
52731   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52732   {
52733     try {
52734       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52735     } catch (std::out_of_range& e) {
52736       {
52737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52738       };
52739     } catch (std::exception& e) {
52740       {
52741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (...) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52746       };
52747     }
52748   }
52749   jresult = (unsigned long)result;
52750   return jresult;
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52755   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52756   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52757
52758   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52759   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52760   {
52761     try {
52762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (...) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52774       };
52775     }
52776   }
52777 }
52778
52779
52780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52781   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52782   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52783
52784   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52785   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52786   {
52787     try {
52788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52796       };
52797     } catch (...) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52800       };
52801     }
52802   }
52803 }
52804
52805
52806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52807   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52808   Dali::Actor arg2 ;
52809   bool arg3 ;
52810   Dali::DevelActor::VisibilityChange::Type arg4 ;
52811   Dali::Actor *argp2 ;
52812
52813   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52814   argp2 = (Dali::Actor *)jarg2;
52815   if (!argp2) {
52816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52817     return ;
52818   }
52819   arg2 = *argp2;
52820   arg3 = jarg3 ? true : false;
52821   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52822   {
52823     try {
52824       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52825     } catch (std::out_of_range& e) {
52826       {
52827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52828       };
52829     } catch (std::exception& e) {
52830       {
52831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (...) {
52834       {
52835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52836       };
52837     }
52838   }
52839 }
52840
52841
52842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52843   void * jresult ;
52844   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52845
52846   {
52847     try {
52848       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52849     } catch (std::out_of_range& e) {
52850       {
52851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52852       };
52853     } catch (std::exception& e) {
52854       {
52855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52856       };
52857     } catch (...) {
52858       {
52859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52860       };
52861     }
52862   }
52863   jresult = (void *)result;
52864   return jresult;
52865 }
52866
52867
52868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52869   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52870
52871   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52872   {
52873     try {
52874       delete arg1;
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52882       };
52883     } catch (...) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52886       };
52887     }
52888   }
52889 }
52890
52891
52892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52893   void * jresult ;
52894   Dali::Timer *result = 0 ;
52895
52896   {
52897     try {
52898       result = (Dali::Timer *)new Dali::Timer();
52899     } catch (std::out_of_range& e) {
52900       {
52901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (std::exception& e) {
52904       {
52905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52906       };
52907     } catch (...) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52910       };
52911     }
52912   }
52913   jresult = (void *)result;
52914   return jresult;
52915 }
52916
52917
52918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52919   void * jresult ;
52920   unsigned int arg1 ;
52921   Dali::Timer result;
52922
52923   arg1 = (unsigned int)jarg1;
52924   {
52925     try {
52926       result = Dali::Timer::New(arg1);
52927     } catch (std::out_of_range& e) {
52928       {
52929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52930       };
52931     } catch (std::exception& e) {
52932       {
52933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (...) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52938       };
52939     }
52940   }
52941   jresult = new Dali::Timer((const Dali::Timer &)result);
52942   return jresult;
52943 }
52944
52945
52946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52947   void * jresult ;
52948   Dali::Timer *arg1 = 0 ;
52949   Dali::Timer *result = 0 ;
52950
52951   arg1 = (Dali::Timer *)jarg1;
52952   if (!arg1) {
52953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52954     return 0;
52955   }
52956   {
52957     try {
52958       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52959     } catch (std::out_of_range& e) {
52960       {
52961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52962       };
52963     } catch (std::exception& e) {
52964       {
52965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52966       };
52967     } catch (...) {
52968       {
52969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52970       };
52971     }
52972   }
52973   jresult = (void *)result;
52974   return jresult;
52975 }
52976
52977
52978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52979   void * jresult ;
52980   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52981   Dali::Timer *arg2 = 0 ;
52982   Dali::Timer *result = 0 ;
52983
52984   arg1 = (Dali::Timer *)jarg1;
52985   arg2 = (Dali::Timer *)jarg2;
52986   if (!arg2) {
52987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52988     return 0;
52989   }
52990   {
52991     try {
52992       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53004       };
53005     }
53006   }
53007   jresult = (void *)result;
53008   return jresult;
53009 }
53010
53011
53012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
53013   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53014
53015   arg1 = (Dali::Timer *)jarg1;
53016   {
53017     try {
53018       delete arg1;
53019     } catch (std::out_of_range& e) {
53020       {
53021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53022       };
53023     } catch (std::exception& e) {
53024       {
53025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53026       };
53027     } catch (...) {
53028       {
53029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53030       };
53031     }
53032   }
53033 }
53034
53035
53036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
53037   void * jresult ;
53038   Dali::BaseHandle arg1 ;
53039   Dali::BaseHandle *argp1 ;
53040   Dali::Timer result;
53041
53042   argp1 = (Dali::BaseHandle *)jarg1;
53043   if (!argp1) {
53044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53045     return 0;
53046   }
53047   arg1 = *argp1;
53048   {
53049     try {
53050       result = Dali::Timer::DownCast(arg1);
53051     } catch (std::out_of_range& e) {
53052       {
53053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (std::exception& e) {
53056       {
53057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065   jresult = new Dali::Timer((const Dali::Timer &)result);
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
53071   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53072
53073   arg1 = (Dali::Timer *)jarg1;
53074   {
53075     try {
53076       (arg1)->Start();
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53088       };
53089     }
53090   }
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53095   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53096
53097   arg1 = (Dali::Timer *)jarg1;
53098   {
53099     try {
53100       (arg1)->Stop();
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (...) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53112       };
53113     }
53114   }
53115 }
53116
53117
53118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53119   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53120   unsigned int arg2 ;
53121
53122   arg1 = (Dali::Timer *)jarg1;
53123   arg2 = (unsigned int)jarg2;
53124   {
53125     try {
53126       (arg1)->SetInterval(arg2);
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53134       };
53135     } catch (...) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53138       };
53139     }
53140   }
53141 }
53142
53143
53144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53145   unsigned int jresult ;
53146   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53147   unsigned int result;
53148
53149   arg1 = (Dali::Timer *)jarg1;
53150   {
53151     try {
53152       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167   jresult = result;
53168   return jresult;
53169 }
53170
53171
53172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53173   unsigned int jresult ;
53174   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53175   bool result;
53176
53177   arg1 = (Dali::Timer *)jarg1;
53178   {
53179     try {
53180       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53192       };
53193     }
53194   }
53195   jresult = result;
53196   return jresult;
53197 }
53198
53199
53200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53201   void * jresult ;
53202   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53203   Dali::Timer::TimerSignalType *result = 0 ;
53204
53205   arg1 = (Dali::Timer *)jarg1;
53206   {
53207     try {
53208       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53209     } catch (std::out_of_range& e) {
53210       {
53211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (std::exception& e) {
53214       {
53215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53216       };
53217     } catch (...) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53220       };
53221     }
53222   }
53223   jresult = (void *)result;
53224   return jresult;
53225 }
53226
53227
53228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53229   void * jresult ;
53230   Dali::DragAndDropDetector *result = 0 ;
53231
53232   {
53233     try {
53234       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53246       };
53247     }
53248   }
53249   jresult = (void *)result;
53250   return jresult;
53251 }
53252
53253
53254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53255   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53256
53257   arg1 = (Dali::DragAndDropDetector *)jarg1;
53258   {
53259     try {
53260       delete arg1;
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275 }
53276
53277
53278 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53279   char * jresult ;
53280   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53281   std::string *result = 0 ;
53282
53283   arg1 = (Dali::DragAndDropDetector *)jarg1;
53284   {
53285     try {
53286       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (...) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53298       };
53299     }
53300   }
53301   jresult = SWIG_csharp_string_callback(result->c_str());
53302   return jresult;
53303 }
53304
53305
53306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53307   void * jresult ;
53308   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53309   Dali::Vector2 result;
53310
53311   arg1 = (Dali::DragAndDropDetector *)jarg1;
53312   {
53313     try {
53314       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53315     } catch (std::out_of_range& e) {
53316       {
53317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53318       };
53319     } catch (std::exception& e) {
53320       {
53321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53322       };
53323     } catch (...) {
53324       {
53325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53326       };
53327     }
53328   }
53329   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53335   void * jresult ;
53336   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53337   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53338
53339   arg1 = (Dali::DragAndDropDetector *)jarg1;
53340   {
53341     try {
53342       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53354       };
53355     }
53356   }
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53363   void * jresult ;
53364   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53365   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53366
53367   arg1 = (Dali::DragAndDropDetector *)jarg1;
53368   {
53369     try {
53370       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53371     } catch (std::out_of_range& e) {
53372       {
53373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53374       };
53375     } catch (std::exception& e) {
53376       {
53377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53378       };
53379     } catch (...) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53382       };
53383     }
53384   }
53385   jresult = (void *)result;
53386   return jresult;
53387 }
53388
53389
53390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53391   void * jresult ;
53392   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53393   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53394
53395   arg1 = (Dali::DragAndDropDetector *)jarg1;
53396   {
53397     try {
53398       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53399     } catch (std::out_of_range& e) {
53400       {
53401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53402       };
53403     } catch (std::exception& e) {
53404       {
53405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53410       };
53411     }
53412   }
53413   jresult = (void *)result;
53414   return jresult;
53415 }
53416
53417
53418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53419   void * jresult ;
53420   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53421   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53422
53423   arg1 = (Dali::DragAndDropDetector *)jarg1;
53424   {
53425     try {
53426       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53438       };
53439     }
53440   }
53441   jresult = (void *)result;
53442   return jresult;
53443 }
53444
53445
53446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53447   void * jresult ;
53448   Dali::ApplicationExtensions *result = 0 ;
53449
53450   {
53451     try {
53452       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53453     } catch (std::out_of_range& e) {
53454       {
53455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53456       };
53457     } catch (std::exception& e) {
53458       {
53459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53460       };
53461     } catch (...) {
53462       {
53463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53464       };
53465     }
53466   }
53467   jresult = (void *)result;
53468   return jresult;
53469 }
53470
53471
53472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53473   void * jresult ;
53474   Dali::Application *arg1 = (Dali::Application *) 0 ;
53475   Dali::ApplicationExtensions *result = 0 ;
53476
53477   arg1 = (Dali::Application *)jarg1;
53478   {
53479     try {
53480       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53481     } catch (std::out_of_range& e) {
53482       {
53483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53484       };
53485     } catch (std::exception& e) {
53486       {
53487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (...) {
53490       {
53491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53492       };
53493     }
53494   }
53495   jresult = (void *)result;
53496   return jresult;
53497 }
53498
53499
53500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53501   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53502
53503   arg1 = (Dali::ApplicationExtensions *)jarg1;
53504   {
53505     try {
53506       delete arg1;
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53514       };
53515     } catch (...) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53518       };
53519     }
53520   }
53521 }
53522
53523
53524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53525   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53526
53527   arg1 = (Dali::ApplicationExtensions *)jarg1;
53528   {
53529     try {
53530       (arg1)->Init();
53531     } catch (std::out_of_range& e) {
53532       {
53533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53534       };
53535     } catch (std::exception& e) {
53536       {
53537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53538       };
53539     } catch (...) {
53540       {
53541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53542       };
53543     }
53544   }
53545 }
53546
53547
53548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53549   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53550
53551   arg1 = (Dali::ApplicationExtensions *)jarg1;
53552   {
53553     try {
53554       (arg1)->Terminate();
53555     } catch (std::out_of_range& e) {
53556       {
53557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (std::exception& e) {
53560       {
53561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (...) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53566       };
53567     }
53568   }
53569 }
53570
53571
53572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53573   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53574
53575   arg1 = (Dali::ApplicationExtensions *)jarg1;
53576   {
53577     try {
53578       (arg1)->Pause();
53579     } catch (std::out_of_range& e) {
53580       {
53581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53582       };
53583     } catch (std::exception& e) {
53584       {
53585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53586       };
53587     } catch (...) {
53588       {
53589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53590       };
53591     }
53592   }
53593 }
53594
53595
53596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53597   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53598
53599   arg1 = (Dali::ApplicationExtensions *)jarg1;
53600   {
53601     try {
53602       (arg1)->Resume();
53603     } catch (std::out_of_range& e) {
53604       {
53605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53606       };
53607     } catch (std::exception& e) {
53608       {
53609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53610       };
53611     } catch (...) {
53612       {
53613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53614       };
53615     }
53616   }
53617 }
53618
53619
53620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53621   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53622
53623   arg1 = (Dali::ApplicationExtensions *)jarg1;
53624   {
53625     try {
53626       (arg1)->LanguageChange();
53627     } catch (std::out_of_range& e) {
53628       {
53629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53630       };
53631     } catch (std::exception& e) {
53632       {
53633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53634       };
53635     } catch (...) {
53636       {
53637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53638       };
53639     }
53640   }
53641 }
53642
53643
53644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53645   void * jresult ;
53646   Dali::PositionSize arg1 ;
53647   std::string *arg2 = 0 ;
53648   bool arg3 ;
53649   Dali::PositionSize *argp1 ;
53650   Dali::Window result;
53651
53652   argp1 = (Dali::PositionSize *)jarg1;
53653   if (!argp1) {
53654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53655     return 0;
53656   }
53657   arg1 = *argp1;
53658   if (!jarg2) {
53659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53660     return 0;
53661   }
53662   std::string arg2_str(jarg2);
53663   arg2 = &arg2_str;
53664   arg3 = jarg3 ? true : false;
53665   {
53666     try {
53667       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53668     } catch (std::out_of_range& e) {
53669       {
53670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53671       };
53672     } catch (std::exception& e) {
53673       {
53674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53675       };
53676     } catch (...) {
53677       {
53678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53679       };
53680     }
53681   }
53682   jresult = new Dali::Window((const Dali::Window &)result);
53683
53684   //argout typemap for const std::string&
53685
53686   return jresult;
53687 }
53688
53689
53690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53691   void * jresult ;
53692   Dali::PositionSize arg1 ;
53693   std::string *arg2 = 0 ;
53694   Dali::PositionSize *argp1 ;
53695   Dali::Window result;
53696
53697   argp1 = (Dali::PositionSize *)jarg1;
53698   if (!argp1) {
53699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53700     return 0;
53701   }
53702   arg1 = *argp1;
53703   if (!jarg2) {
53704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53705     return 0;
53706   }
53707   std::string arg2_str(jarg2);
53708   arg2 = &arg2_str;
53709   {
53710     try {
53711       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53712     } catch (std::out_of_range& e) {
53713       {
53714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (std::exception& e) {
53717       {
53718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (...) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53723       };
53724     }
53725   }
53726   jresult = new Dali::Window((const Dali::Window &)result);
53727
53728   //argout typemap for const std::string&
53729
53730   return jresult;
53731 }
53732
53733
53734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53735   void * jresult ;
53736   Dali::PositionSize arg1 ;
53737   std::string *arg2 = 0 ;
53738   std::string *arg3 = 0 ;
53739   bool arg4 ;
53740   Dali::PositionSize *argp1 ;
53741   Dali::Window result;
53742
53743   argp1 = (Dali::PositionSize *)jarg1;
53744   if (!argp1) {
53745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53746     return 0;
53747   }
53748   arg1 = *argp1;
53749   if (!jarg2) {
53750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53751     return 0;
53752   }
53753   std::string arg2_str(jarg2);
53754   arg2 = &arg2_str;
53755   if (!jarg3) {
53756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53757     return 0;
53758   }
53759   std::string arg3_str(jarg3);
53760   arg3 = &arg3_str;
53761   arg4 = jarg4 ? true : false;
53762   {
53763     try {
53764       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53765     } catch (std::out_of_range& e) {
53766       {
53767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (std::exception& e) {
53770       {
53771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53772       };
53773     } catch (...) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53776       };
53777     }
53778   }
53779   jresult = new Dali::Window((const Dali::Window &)result);
53780
53781   //argout typemap for const std::string&
53782
53783
53784   //argout typemap for const std::string&
53785
53786   return jresult;
53787 }
53788
53789
53790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53791   void * jresult ;
53792   Dali::PositionSize arg1 ;
53793   std::string *arg2 = 0 ;
53794   std::string *arg3 = 0 ;
53795   Dali::PositionSize *argp1 ;
53796   Dali::Window result;
53797
53798   argp1 = (Dali::PositionSize *)jarg1;
53799   if (!argp1) {
53800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53801     return 0;
53802   }
53803   arg1 = *argp1;
53804   if (!jarg2) {
53805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53806     return 0;
53807   }
53808   std::string arg2_str(jarg2);
53809   arg2 = &arg2_str;
53810   if (!jarg3) {
53811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53812     return 0;
53813   }
53814   std::string arg3_str(jarg3);
53815   arg3 = &arg3_str;
53816   {
53817     try {
53818       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (...) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53830       };
53831     }
53832   }
53833   jresult = new Dali::Window((const Dali::Window &)result);
53834
53835   //argout typemap for const std::string&
53836
53837
53838   //argout typemap for const std::string&
53839
53840   return jresult;
53841 }
53842
53843
53844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53845   void * jresult ;
53846   Dali::Window *result = 0 ;
53847
53848   {
53849     try {
53850       result = (Dali::Window *)new Dali::Window();
53851     } catch (std::out_of_range& e) {
53852       {
53853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53854       };
53855     } catch (std::exception& e) {
53856       {
53857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (...) {
53860       {
53861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53862       };
53863     }
53864   }
53865   jresult = (void *)result;
53866   return jresult;
53867 }
53868
53869
53870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53871   Dali::Window *arg1 = (Dali::Window *) 0 ;
53872
53873   arg1 = (Dali::Window *)jarg1;
53874   {
53875     try {
53876       delete arg1;
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53888       };
53889     }
53890   }
53891 }
53892
53893
53894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53895   void * jresult ;
53896   Dali::Window *arg1 = 0 ;
53897   Dali::Window *result = 0 ;
53898
53899   arg1 = (Dali::Window *)jarg1;
53900   if (!arg1) {
53901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53902     return 0;
53903   }
53904   {
53905     try {
53906       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53907     } catch (std::out_of_range& e) {
53908       {
53909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53910       };
53911     } catch (std::exception& e) {
53912       {
53913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53918       };
53919     }
53920   }
53921   jresult = (void *)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53927   void * jresult ;
53928   Dali::Window *arg1 = (Dali::Window *) 0 ;
53929   Dali::Window *arg2 = 0 ;
53930   Dali::Window *result = 0 ;
53931
53932   arg1 = (Dali::Window *)jarg1;
53933   arg2 = (Dali::Window *)jarg2;
53934   if (!arg2) {
53935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53936     return 0;
53937   }
53938   {
53939     try {
53940       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53941     } catch (std::out_of_range& e) {
53942       {
53943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53944       };
53945     } catch (std::exception& e) {
53946       {
53947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53952       };
53953     }
53954   }
53955   jresult = (void *)result;
53956   return jresult;
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53961   Dali::Window *arg1 = (Dali::Window *) 0 ;
53962   Dali::Window::IndicatorVisibleMode arg2 ;
53963
53964   arg1 = (Dali::Window *)jarg1;
53965   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53966   {
53967     try {
53968       (arg1)->ShowIndicator(arg2);
53969     } catch (std::out_of_range& e) {
53970       {
53971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (std::exception& e) {
53974       {
53975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (...) {
53978       {
53979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53980       };
53981     }
53982   }
53983 }
53984
53985
53986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53987   Dali::Window *arg1 = (Dali::Window *) 0 ;
53988   Dali::Window::IndicatorBgOpacity arg2 ;
53989
53990   arg1 = (Dali::Window *)jarg1;
53991   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53992   {
53993     try {
53994       (arg1)->SetIndicatorBgOpacity(arg2);
53995     } catch (std::out_of_range& e) {
53996       {
53997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (std::exception& e) {
54000       {
54001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54002       };
54003     } catch (...) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54006       };
54007     }
54008   }
54009 }
54010
54011
54012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
54013   Dali::Window *arg1 = (Dali::Window *) 0 ;
54014   Dali::Window::WindowOrientation arg2 ;
54015
54016   arg1 = (Dali::Window *)jarg1;
54017   arg2 = (Dali::Window::WindowOrientation)jarg2;
54018   {
54019     try {
54020       (arg1)->RotateIndicator(arg2);
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (...) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54032       };
54033     }
54034   }
54035 }
54036
54037
54038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
54039   Dali::Window *arg1 = (Dali::Window *) 0 ;
54040   std::string arg2 ;
54041   std::string arg3 ;
54042
54043   arg1 = (Dali::Window *)jarg1;
54044   if (!jarg2) {
54045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54046     return ;
54047   }
54048   (&arg2)->assign(jarg2);
54049   if (!jarg3) {
54050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54051     return ;
54052   }
54053   (&arg3)->assign(jarg3);
54054   {
54055     try {
54056       (arg1)->SetClass(arg2,arg3);
54057     } catch (std::out_of_range& e) {
54058       {
54059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (std::exception& e) {
54062       {
54063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54068       };
54069     }
54070   }
54071 }
54072
54073
54074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
54075   Dali::Window *arg1 = (Dali::Window *) 0 ;
54076
54077   arg1 = (Dali::Window *)jarg1;
54078   {
54079     try {
54080       (arg1)->Raise();
54081     } catch (std::out_of_range& e) {
54082       {
54083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54084       };
54085     } catch (std::exception& e) {
54086       {
54087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54088       };
54089     } catch (...) {
54090       {
54091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54092       };
54093     }
54094   }
54095 }
54096
54097
54098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54099   Dali::Window *arg1 = (Dali::Window *) 0 ;
54100
54101   arg1 = (Dali::Window *)jarg1;
54102   {
54103     try {
54104       (arg1)->Lower();
54105     } catch (std::out_of_range& e) {
54106       {
54107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54108       };
54109     } catch (std::exception& e) {
54110       {
54111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54112       };
54113     } catch (...) {
54114       {
54115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54116       };
54117     }
54118   }
54119 }
54120
54121
54122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54123   Dali::Window *arg1 = (Dali::Window *) 0 ;
54124
54125   arg1 = (Dali::Window *)jarg1;
54126   {
54127     try {
54128       (arg1)->Activate();
54129     } catch (std::out_of_range& e) {
54130       {
54131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54132       };
54133     } catch (std::exception& e) {
54134       {
54135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54140       };
54141     }
54142   }
54143 }
54144
54145
54146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54147   Dali::Window *arg1 = (Dali::Window *) 0 ;
54148   Dali::Window::WindowOrientation arg2 ;
54149
54150   arg1 = (Dali::Window *)jarg1;
54151   arg2 = (Dali::Window::WindowOrientation)jarg2;
54152   {
54153     try {
54154       (arg1)->AddAvailableOrientation(arg2);
54155     } catch (std::out_of_range& e) {
54156       {
54157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (std::exception& e) {
54160       {
54161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54162       };
54163     } catch (...) {
54164       {
54165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54166       };
54167     }
54168   }
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54173   Dali::Window *arg1 = (Dali::Window *) 0 ;
54174   Dali::Window::WindowOrientation arg2 ;
54175
54176   arg1 = (Dali::Window *)jarg1;
54177   arg2 = (Dali::Window::WindowOrientation)jarg2;
54178   {
54179     try {
54180       (arg1)->RemoveAvailableOrientation(arg2);
54181     } catch (std::out_of_range& e) {
54182       {
54183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (std::exception& e) {
54186       {
54187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (...) {
54190       {
54191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54192       };
54193     }
54194   }
54195 }
54196
54197
54198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54199   Dali::Window *arg1 = (Dali::Window *) 0 ;
54200   Dali::Window::WindowOrientation arg2 ;
54201
54202   arg1 = (Dali::Window *)jarg1;
54203   arg2 = (Dali::Window::WindowOrientation)jarg2;
54204   {
54205     try {
54206       (arg1)->SetPreferredOrientation(arg2);
54207     } catch (std::out_of_range& e) {
54208       {
54209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54210       };
54211     } catch (std::exception& e) {
54212       {
54213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54214       };
54215     } catch (...) {
54216       {
54217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54218       };
54219     }
54220   }
54221 }
54222
54223
54224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54225   int jresult ;
54226   Dali::Window *arg1 = (Dali::Window *) 0 ;
54227   Dali::Window::WindowOrientation result;
54228
54229   arg1 = (Dali::Window *)jarg1;
54230   {
54231     try {
54232       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54233     } catch (std::out_of_range& e) {
54234       {
54235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54236       };
54237     } catch (std::exception& e) {
54238       {
54239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54240       };
54241     } catch (...) {
54242       {
54243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54244       };
54245     }
54246   }
54247   jresult = (int)result;
54248   return jresult;
54249 }
54250
54251
54252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54253   void * jresult ;
54254   Dali::Window *arg1 = (Dali::Window *) 0 ;
54255   Dali::DragAndDropDetector result;
54256
54257   arg1 = (Dali::Window *)jarg1;
54258   {
54259     try {
54260       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54261     } catch (std::out_of_range& e) {
54262       {
54263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54264       };
54265     } catch (std::exception& e) {
54266       {
54267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54268       };
54269     } catch (...) {
54270       {
54271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54272       };
54273     }
54274   }
54275   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54276   return jresult;
54277 }
54278
54279
54280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54281   void * jresult ;
54282   Dali::Window *arg1 = (Dali::Window *) 0 ;
54283   Dali::Any result;
54284
54285   arg1 = (Dali::Window *)jarg1;
54286   {
54287     try {
54288       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54289     } catch (std::out_of_range& e) {
54290       {
54291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54292       };
54293     } catch (std::exception& e) {
54294       {
54295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54300       };
54301     }
54302   }
54303   jresult = new Dali::Any((const Dali::Any &)result);
54304   return jresult;
54305 }
54306
54307
54308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54309   void * jresult ;
54310   Dali::Window arg1 ;
54311   Dali::Window *argp1 ;
54312   Dali::DevelWindow::FocusSignalType *result = 0 ;
54313
54314   argp1 = (Dali::Window *)jarg1;
54315   if (!argp1) {
54316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54317     return 0;
54318   }
54319   arg1 = *argp1;
54320   {
54321     try {
54322       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54323     } catch (std::out_of_range& e) {
54324       {
54325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54326       };
54327     } catch (std::exception& e) {
54328       {
54329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54330       };
54331     } catch (...) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54334       };
54335     }
54336   }
54337   jresult = (void *)result;
54338   return jresult;
54339 }
54340
54341
54342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54343   Dali::Window arg1 ;
54344   bool arg2 ;
54345   Dali::Window *argp1 ;
54346
54347   argp1 = (Dali::Window *)jarg1;
54348   if (!argp1) {
54349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54350     return ;
54351   }
54352   arg1 = *argp1;
54353   arg2 = jarg2 ? true : false;
54354   {
54355     try {
54356       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54357     } catch (std::out_of_range& e) {
54358       {
54359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54360       };
54361     } catch (std::exception& e) {
54362       {
54363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54364       };
54365     } catch (...) {
54366       {
54367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54368       };
54369     }
54370   }
54371 }
54372
54373
54374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54375   unsigned int jresult ;
54376   Dali::Window arg1 ;
54377   Dali::Window *argp1 ;
54378   bool result;
54379
54380   argp1 = (Dali::Window *)jarg1;
54381   if (!argp1) {
54382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54383     return 0;
54384   }
54385   arg1 = *argp1;
54386   {
54387     try {
54388       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54389     } catch (std::out_of_range& e) {
54390       {
54391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54392       };
54393     } catch (std::exception& e) {
54394       {
54395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54396       };
54397     } catch (...) {
54398       {
54399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54400       };
54401     }
54402   }
54403   jresult = result;
54404   return jresult;
54405 }
54406
54407
54408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54409   Dali::Window arg1 ;
54410   Dali::Window *argp1 ;
54411
54412   argp1 = (Dali::Window *)jarg1;
54413   if (!argp1) {
54414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54415     return ;
54416   }
54417   arg1 = *argp1;
54418   {
54419     try {
54420       Dali::DevelWindow::Show(arg1);
54421     } catch (std::out_of_range& e) {
54422       {
54423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54424       };
54425     } catch (std::exception& e) {
54426       {
54427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54428       };
54429     } catch (...) {
54430       {
54431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54432       };
54433     }
54434   }
54435 }
54436
54437
54438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54439   Dali::Window arg1 ;
54440   Dali::Window *argp1 ;
54441
54442   argp1 = (Dali::Window *)jarg1;
54443   if (!argp1) {
54444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54445     return ;
54446   }
54447   arg1 = *argp1;
54448   {
54449     try {
54450       Dali::DevelWindow::Hide(arg1);
54451     } catch (std::out_of_range& e) {
54452       {
54453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54454       };
54455     } catch (std::exception& e) {
54456       {
54457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (...) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54462       };
54463     }
54464   }
54465 }
54466
54467
54468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54469   unsigned int jresult ;
54470   Dali::Window arg1 ;
54471   Dali::Window *argp1 ;
54472   bool result;
54473
54474   argp1 = (Dali::Window *)jarg1;
54475   if (!argp1) {
54476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54477     return 0;
54478   }
54479   arg1 = *argp1;
54480   {
54481     try {
54482       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54483     } catch (std::out_of_range& e) {
54484       {
54485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54486       };
54487     } catch (std::exception& e) {
54488       {
54489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (...) {
54492       {
54493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54494       };
54495     }
54496   }
54497   jresult = result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54503   unsigned int jresult ;
54504   Dali::Window arg1 ;
54505   Dali::Window *argp1 ;
54506   unsigned int result;
54507
54508   argp1 = (Dali::Window *)jarg1;
54509   if (!argp1) {
54510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54511     return 0;
54512   }
54513   arg1 = *argp1;
54514   {
54515     try {
54516       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54528       };
54529     }
54530   }
54531   jresult = result;
54532   return jresult;
54533 }
54534
54535
54536 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54537   char * jresult ;
54538   Dali::Window arg1 ;
54539   unsigned int arg2 ;
54540   Dali::Window *argp1 ;
54541   std::string result;
54542
54543   argp1 = (Dali::Window *)jarg1;
54544   if (!argp1) {
54545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54546     return 0;
54547   }
54548   arg1 = *argp1;
54549   arg2 = (unsigned int)jarg2;
54550   {
54551     try {
54552       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54553     } catch (std::out_of_range& e) {
54554       {
54555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54556       };
54557     } catch (std::exception& e) {
54558       {
54559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54560       };
54561     } catch (...) {
54562       {
54563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54564       };
54565     }
54566   }
54567   jresult = SWIG_csharp_string_callback((&result)->c_str());
54568   return jresult;
54569 }
54570
54571
54572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54573   unsigned int jresult ;
54574   Dali::Window arg1 ;
54575   std::string *arg2 = 0 ;
54576   std::string *arg3 = 0 ;
54577   Dali::Window *argp1 ;
54578   unsigned int result;
54579
54580   argp1 = (Dali::Window *)jarg1;
54581   if (!argp1) {
54582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54583     return 0;
54584   }
54585   arg1 = *argp1;
54586   if (!jarg2) {
54587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54588     return 0;
54589   }
54590   std::string arg2_str(jarg2);
54591   arg2 = &arg2_str;
54592   if (!jarg3) {
54593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54594     return 0;
54595   }
54596   std::string arg3_str(jarg3);
54597   arg3 = &arg3_str;
54598   {
54599     try {
54600       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54601     } catch (std::out_of_range& e) {
54602       {
54603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54604       };
54605     } catch (std::exception& e) {
54606       {
54607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54608       };
54609     } catch (...) {
54610       {
54611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54612       };
54613     }
54614   }
54615   jresult = result;
54616
54617   //argout typemap for const std::string&
54618
54619
54620   //argout typemap for const std::string&
54621
54622   return jresult;
54623 }
54624
54625
54626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54627   unsigned int jresult ;
54628   Dali::Window arg1 ;
54629   unsigned int arg2 ;
54630   Dali::Window *argp1 ;
54631   bool result;
54632
54633   argp1 = (Dali::Window *)jarg1;
54634   if (!argp1) {
54635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54636     return 0;
54637   }
54638   arg1 = *argp1;
54639   arg2 = (unsigned int)jarg2;
54640   {
54641     try {
54642       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54643     } catch (std::out_of_range& e) {
54644       {
54645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54646       };
54647     } catch (std::exception& e) {
54648       {
54649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54650       };
54651     } catch (...) {
54652       {
54653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54654       };
54655     }
54656   }
54657   jresult = result;
54658   return jresult;
54659 }
54660
54661
54662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54663   unsigned int jresult ;
54664   Dali::Window arg1 ;
54665   unsigned int arg2 ;
54666   std::string *arg3 = 0 ;
54667   Dali::Window *argp1 ;
54668   bool result;
54669
54670   argp1 = (Dali::Window *)jarg1;
54671   if (!argp1) {
54672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54673     return 0;
54674   }
54675   arg1 = *argp1;
54676   arg2 = (unsigned int)jarg2;
54677   if (!jarg3) {
54678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54679     return 0;
54680   }
54681   std::string arg3_str(jarg3);
54682   arg3 = &arg3_str;
54683   {
54684     try {
54685       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = result;
54701
54702   //argout typemap for const std::string&
54703
54704   return jresult;
54705 }
54706
54707
54708 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54709   char * jresult ;
54710   Dali::Window arg1 ;
54711   unsigned int arg2 ;
54712   Dali::Window *argp1 ;
54713   std::string result;
54714
54715   argp1 = (Dali::Window *)jarg1;
54716   if (!argp1) {
54717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54718     return 0;
54719   }
54720   arg1 = *argp1;
54721   arg2 = (unsigned int)jarg2;
54722   {
54723     try {
54724       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54725     } catch (std::out_of_range& e) {
54726       {
54727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54728       };
54729     } catch (std::exception& e) {
54730       {
54731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54736       };
54737     }
54738   }
54739   jresult = SWIG_csharp_string_callback((&result)->c_str());
54740   return jresult;
54741 }
54742
54743
54744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54745   unsigned int jresult ;
54746   Dali::Window arg1 ;
54747   std::string *arg2 = 0 ;
54748   Dali::Window *argp1 ;
54749   unsigned int result;
54750
54751   argp1 = (Dali::Window *)jarg1;
54752   if (!argp1) {
54753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54754     return 0;
54755   }
54756   arg1 = *argp1;
54757   if (!jarg2) {
54758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54759     return 0;
54760   }
54761   std::string arg2_str(jarg2);
54762   arg2 = &arg2_str;
54763   {
54764     try {
54765       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54766     } catch (std::out_of_range& e) {
54767       {
54768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54769       };
54770     } catch (std::exception& e) {
54771       {
54772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54773       };
54774     } catch (...) {
54775       {
54776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54777       };
54778     }
54779   }
54780   jresult = result;
54781
54782   //argout typemap for const std::string&
54783
54784   return jresult;
54785 }
54786
54787
54788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54789   Dali::Window arg1 ;
54790   Dali::Rect< int > *arg2 = 0 ;
54791   Dali::Window *argp1 ;
54792
54793   argp1 = (Dali::Window *)jarg1;
54794   if (!argp1) {
54795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54796     return ;
54797   }
54798   arg1 = *argp1;
54799   arg2 = (Dali::Rect< int > *)jarg2;
54800   if (!arg2) {
54801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54802     return ;
54803   }
54804   {
54805     try {
54806       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54807     } catch (std::out_of_range& e) {
54808       {
54809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54810       };
54811     } catch (std::exception& e) {
54812       {
54813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54814       };
54815     } catch (...) {
54816       {
54817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54818       };
54819     }
54820   }
54821 }
54822
54823
54824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54825   Dali::Window arg1 ;
54826   Dali::DevelWindow::Type arg2 ;
54827   Dali::Window *argp1 ;
54828
54829   argp1 = (Dali::Window *)jarg1;
54830   if (!argp1) {
54831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54832     return ;
54833   }
54834   arg1 = *argp1;
54835   arg2 = (Dali::DevelWindow::Type)jarg2;
54836   {
54837     try {
54838       Dali::DevelWindow::SetType(arg1,arg2);
54839     } catch (std::out_of_range& e) {
54840       {
54841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54842       };
54843     } catch (std::exception& e) {
54844       {
54845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54850       };
54851     }
54852   }
54853 }
54854
54855
54856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54857   int jresult ;
54858   Dali::Window arg1 ;
54859   Dali::Window *argp1 ;
54860   Dali::DevelWindow::Type result;
54861
54862   argp1 = (Dali::Window *)jarg1;
54863   if (!argp1) {
54864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54865     return 0;
54866   }
54867   arg1 = *argp1;
54868   {
54869     try {
54870       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54871     } catch (std::out_of_range& e) {
54872       {
54873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54874       };
54875     } catch (std::exception& e) {
54876       {
54877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54878       };
54879     } catch (...) {
54880       {
54881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54882       };
54883     }
54884   }
54885   jresult = (int)result;
54886   return jresult;
54887 }
54888
54889
54890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54891   unsigned int jresult ;
54892   Dali::Window arg1 ;
54893   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54894   Dali::Window *argp1 ;
54895   bool result;
54896
54897   argp1 = (Dali::Window *)jarg1;
54898   if (!argp1) {
54899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54900     return 0;
54901   }
54902   arg1 = *argp1;
54903   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54904   {
54905     try {
54906       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54907     } catch (std::out_of_range& e) {
54908       {
54909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54910       };
54911     } catch (std::exception& e) {
54912       {
54913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54914       };
54915     } catch (...) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54918       };
54919     }
54920   }
54921   jresult = result;
54922   return jresult;
54923 }
54924
54925
54926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54927   int jresult ;
54928   Dali::Window arg1 ;
54929   Dali::Window *argp1 ;
54930   Dali::DevelWindow::NotificationLevel::Type result;
54931
54932   argp1 = (Dali::Window *)jarg1;
54933   if (!argp1) {
54934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54935     return 0;
54936   }
54937   arg1 = *argp1;
54938   {
54939     try {
54940       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54941     } catch (std::out_of_range& e) {
54942       {
54943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54944       };
54945     } catch (std::exception& e) {
54946       {
54947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54952       };
54953     }
54954   }
54955   jresult = (int)result;
54956   return jresult;
54957 }
54958
54959
54960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54961   Dali::Window arg1 ;
54962   bool arg2 ;
54963   Dali::Window *argp1 ;
54964
54965   argp1 = (Dali::Window *)jarg1;
54966   if (!argp1) {
54967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54968     return ;
54969   }
54970   arg1 = *argp1;
54971   arg2 = jarg2 ? true : false;
54972   {
54973     try {
54974       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (...) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54986       };
54987     }
54988   }
54989 }
54990
54991
54992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
54993   unsigned int jresult ;
54994   Dali::Window arg1 ;
54995   Dali::Window *argp1 ;
54996   bool result;
54997
54998   argp1 = (Dali::Window *)jarg1;
54999   if (!argp1) {
55000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55001     return 0;
55002   }
55003   arg1 = *argp1;
55004   {
55005     try {
55006       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
55007     } catch (std::out_of_range& e) {
55008       {
55009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55010       };
55011     } catch (std::exception& e) {
55012       {
55013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55014       };
55015     } catch (...) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55018       };
55019     }
55020   }
55021   jresult = result;
55022   return jresult;
55023 }
55024
55025
55026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
55027   unsigned int jresult ;
55028   Dali::Window arg1 ;
55029   Dali::DevelWindow::ScreenMode::Type arg2 ;
55030   Dali::Window *argp1 ;
55031   bool result;
55032
55033   argp1 = (Dali::Window *)jarg1;
55034   if (!argp1) {
55035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55036     return 0;
55037   }
55038   arg1 = *argp1;
55039   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
55040   {
55041     try {
55042       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55050       };
55051     } catch (...) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55054       };
55055     }
55056   }
55057   jresult = result;
55058   return jresult;
55059 }
55060
55061
55062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
55063   int jresult ;
55064   Dali::Window arg1 ;
55065   Dali::Window *argp1 ;
55066   Dali::DevelWindow::ScreenMode::Type result;
55067
55068   argp1 = (Dali::Window *)jarg1;
55069   if (!argp1) {
55070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55071     return 0;
55072   }
55073   arg1 = *argp1;
55074   {
55075     try {
55076       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55088       };
55089     }
55090   }
55091   jresult = (int)result;
55092   return jresult;
55093 }
55094
55095
55096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55097   unsigned int jresult ;
55098   Dali::Window arg1 ;
55099   int arg2 ;
55100   Dali::Window *argp1 ;
55101   bool result;
55102
55103   argp1 = (Dali::Window *)jarg1;
55104   if (!argp1) {
55105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55106     return 0;
55107   }
55108   arg1 = *argp1;
55109   arg2 = (int)jarg2;
55110   {
55111     try {
55112       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55113     } catch (std::out_of_range& e) {
55114       {
55115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55116       };
55117     } catch (std::exception& e) {
55118       {
55119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55120       };
55121     } catch (...) {
55122       {
55123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55124       };
55125     }
55126   }
55127   jresult = result;
55128   return jresult;
55129 }
55130
55131
55132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55133   int jresult ;
55134   Dali::Window arg1 ;
55135   Dali::Window *argp1 ;
55136   int result;
55137
55138   argp1 = (Dali::Window *)jarg1;
55139   if (!argp1) {
55140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55141     return 0;
55142   }
55143   arg1 = *argp1;
55144   {
55145     try {
55146       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55147     } catch (std::out_of_range& e) {
55148       {
55149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (std::exception& e) {
55152       {
55153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55158       };
55159     }
55160   }
55161   jresult = result;
55162   return jresult;
55163 }
55164
55165
55166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55167   void * jresult ;
55168   Dali::Application result;
55169
55170   {
55171     try {
55172       result = Dali::Application::New();
55173     } catch (std::out_of_range& e) {
55174       {
55175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55176       };
55177     } catch (std::exception& e) {
55178       {
55179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55180       };
55181     } catch (...) {
55182       {
55183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55184       };
55185     }
55186   }
55187   jresult = new Dali::Application((const Dali::Application &)result);
55188   return jresult;
55189 }
55190
55191
55192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55193   void * jresult ;
55194   int *arg1 = (int *) 0 ;
55195   char ***arg2 ;
55196   Dali::Application result;
55197
55198   {
55199     // Todo generate argv data from the C# args
55200     char **array;         // two dimensional array
55201     int numStrings = 1;     // number of strings
55202     int stringLength = 30;      // max string length.
55203     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55204     argV = array;
55205
55206     // allocate the string data
55207     for( int i=0; i < numStrings; i++)
55208     {
55209       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55210     }
55211     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55212
55213     strcpy( array[0], "dali-csharp-app");
55214
55215     arg1 = &argC;
55216     arg2 = &argV;
55217   }
55218   {
55219     try {
55220       result = Dali::Application::New(arg1,arg2);
55221     } catch (std::out_of_range& e) {
55222       {
55223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55224       };
55225     } catch (std::exception& e) {
55226       {
55227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55228       };
55229     } catch (...) {
55230       {
55231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55232       };
55233     }
55234   }
55235   jresult = new Dali::Application((const Dali::Application &)result);
55236   return jresult;
55237 }
55238
55239
55240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55241   void * jresult ;
55242   int *arg1 = (int *) 0 ;
55243   char ***arg2 ;
55244   std::string *arg3 = 0 ;
55245   Dali::Application result;
55246
55247   {
55248     // Todo generate argv data from the C# args
55249     char **array;         // two dimensional array
55250     int numStrings = 1;     // number of strings
55251     int stringLength = 30;      // max string length.
55252     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55253     argV = array;
55254
55255     // allocate the string data
55256     for( int i=0; i < numStrings; i++)
55257     {
55258       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55259     }
55260     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55261
55262     strcpy( array[0], "dali-csharp-app");
55263
55264     arg1 = &argC;
55265     arg2 = &argV;
55266   }
55267   if (!jarg3) {
55268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55269     return 0;
55270   }
55271   std::string arg3_str(jarg3);
55272   arg3 = &arg3_str;
55273   {
55274     try {
55275       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55276     } catch (std::out_of_range& e) {
55277       {
55278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55279       };
55280     } catch (std::exception& e) {
55281       {
55282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55287       };
55288     }
55289   }
55290   jresult = new Dali::Application((const Dali::Application &)result);
55291
55292   //argout typemap for const std::string&
55293
55294   return jresult;
55295 }
55296
55297
55298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55299   void * jresult ;
55300   int *arg1 = (int *) 0 ;
55301   char ***arg2 ;
55302   std::string *arg3 = 0 ;
55303   Dali::Application::WINDOW_MODE arg4 ;
55304   Dali::Application result;
55305
55306   {
55307     // Todo generate argv data from the C# args
55308     char **array;         // two dimensional array
55309     int numStrings = 1;     // number of strings
55310     int stringLength = 30;      // max string length.
55311     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55312     argV = array;
55313
55314     // allocate the string data
55315     for( int i=0; i < numStrings; i++)
55316     {
55317       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55318     }
55319     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55320
55321     strcpy( array[0], "dali-csharp-app");
55322
55323     arg1 = &argC;
55324     arg2 = &argV;
55325   }
55326   if (!jarg3) {
55327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55328     return 0;
55329   }
55330   std::string arg3_str(jarg3);
55331   arg3 = &arg3_str;
55332   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55333   {
55334     try {
55335       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55336     } catch (std::out_of_range& e) {
55337       {
55338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55339       };
55340     } catch (std::exception& e) {
55341       {
55342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55347       };
55348     }
55349   }
55350   jresult = new Dali::Application((const Dali::Application &)result);
55351
55352   //argout typemap for const std::string&
55353
55354   return jresult;
55355 }
55356
55357
55358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55359   void * jresult ;
55360   Dali::Application *result = 0 ;
55361
55362   {
55363     try {
55364       result = (Dali::Application *)new Dali::Application();
55365     } catch (std::out_of_range& e) {
55366       {
55367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55368       };
55369     } catch (std::exception& e) {
55370       {
55371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55372       };
55373     } catch (...) {
55374       {
55375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55376       };
55377     }
55378   }
55379   jresult = (void *)result;
55380   return jresult;
55381 }
55382
55383
55384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55385   void * jresult ;
55386   Dali::Application *arg1 = 0 ;
55387   Dali::Application *result = 0 ;
55388
55389   arg1 = (Dali::Application *)jarg1;
55390   if (!arg1) {
55391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55392     return 0;
55393   }
55394   {
55395     try {
55396       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55397     } catch (std::out_of_range& e) {
55398       {
55399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55400       };
55401     } catch (std::exception& e) {
55402       {
55403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55404       };
55405     } catch (...) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55408       };
55409     }
55410   }
55411   jresult = (void *)result;
55412   return jresult;
55413 }
55414
55415
55416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55417   void * jresult ;
55418   Dali::Application *arg1 = (Dali::Application *) 0 ;
55419   Dali::Application *arg2 = 0 ;
55420   Dali::Application *result = 0 ;
55421
55422   arg1 = (Dali::Application *)jarg1;
55423   arg2 = (Dali::Application *)jarg2;
55424   if (!arg2) {
55425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55426     return 0;
55427   }
55428   {
55429     try {
55430       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55431     } catch (std::out_of_range& e) {
55432       {
55433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55434       };
55435     } catch (std::exception& e) {
55436       {
55437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (...) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55442       };
55443     }
55444   }
55445   jresult = (void *)result;
55446   return jresult;
55447 }
55448
55449
55450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55451   Dali::Application *arg1 = (Dali::Application *) 0 ;
55452
55453   arg1 = (Dali::Application *)jarg1;
55454   {
55455     try {
55456       delete arg1;
55457     } catch (std::out_of_range& e) {
55458       {
55459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55460       };
55461     } catch (std::exception& e) {
55462       {
55463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55464       };
55465     } catch (...) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55468       };
55469     }
55470   }
55471 }
55472
55473
55474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55475   Dali::Application *arg1 = (Dali::Application *) 0 ;
55476
55477   arg1 = (Dali::Application *)jarg1;
55478   {
55479     try {
55480       (arg1)->MainLoop();
55481     } catch (std::out_of_range& e) {
55482       {
55483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55484       };
55485     } catch (std::exception& e) {
55486       {
55487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55488       };
55489     } catch (...) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55492       };
55493     }
55494   }
55495 }
55496
55497
55498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55499   Dali::Application *arg1 = (Dali::Application *) 0 ;
55500   Configuration::ContextLoss arg2 ;
55501   Configuration::ContextLoss *argp2 ;
55502
55503   arg1 = (Dali::Application *)jarg1;
55504   argp2 = (Configuration::ContextLoss *)jarg2;
55505   if (!argp2) {
55506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55507     return ;
55508   }
55509   arg2 = *argp2;
55510   {
55511     try {
55512       (arg1)->MainLoop(arg2);
55513     } catch (std::out_of_range& e) {
55514       {
55515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55516       };
55517     } catch (std::exception& e) {
55518       {
55519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55524       };
55525     }
55526   }
55527 }
55528
55529
55530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55531   Dali::Application *arg1 = (Dali::Application *) 0 ;
55532
55533   arg1 = (Dali::Application *)jarg1;
55534   {
55535     try {
55536       (arg1)->Lower();
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55548       };
55549     }
55550   }
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55555   Dali::Application *arg1 = (Dali::Application *) 0 ;
55556
55557   arg1 = (Dali::Application *)jarg1;
55558   {
55559     try {
55560       (arg1)->Quit();
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (...) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55572       };
55573     }
55574   }
55575 }
55576
55577
55578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55579   unsigned int jresult ;
55580   Dali::Application *arg1 = (Dali::Application *) 0 ;
55581   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55582   bool result;
55583
55584   arg1 = (Dali::Application *)jarg1;
55585   arg2 = (Dali::CallbackBase *)jarg2;
55586   {
55587     try {
55588       result = (bool)(arg1)->AddIdle(arg2);
55589     } catch (std::out_of_range& e) {
55590       {
55591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (std::exception& e) {
55594       {
55595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55596       };
55597     } catch (...) {
55598       {
55599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55600       };
55601     }
55602   }
55603   jresult = result;
55604   return jresult;
55605 }
55606
55607
55608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55609   void * jresult ;
55610   Dali::Application *arg1 = (Dali::Application *) 0 ;
55611   Dali::Window result;
55612
55613   arg1 = (Dali::Application *)jarg1;
55614   {
55615     try {
55616       result = (arg1)->GetWindow();
55617     } catch (std::out_of_range& e) {
55618       {
55619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55620       };
55621     } catch (std::exception& e) {
55622       {
55623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55624       };
55625     } catch (...) {
55626       {
55627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55628       };
55629     }
55630   }
55631   jresult = new Dali::Window((const Dali::Window &)result);
55632   return jresult;
55633 }
55634
55635
55636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55637   Dali::Application *arg1 = (Dali::Application *) 0 ;
55638   Dali::PositionSize arg2 ;
55639   std::string *arg3 = 0 ;
55640   Dali::PositionSize *argp2 ;
55641
55642   arg1 = (Dali::Application *)jarg1;
55643   argp2 = (Dali::PositionSize *)jarg2;
55644   if (!argp2) {
55645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55646     return ;
55647   }
55648   arg2 = *argp2;
55649   if (!jarg3) {
55650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55651     return ;
55652   }
55653   std::string arg3_str(jarg3);
55654   arg3 = &arg3_str;
55655   {
55656     try {
55657       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (...) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55669       };
55670     }
55671   }
55672
55673   //argout typemap for const std::string&
55674
55675 }
55676
55677
55678 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55679   char * jresult ;
55680   std::string result;
55681
55682   {
55683     try {
55684       result = Dali::Application::GetResourcePath();
55685     } catch (std::out_of_range& e) {
55686       {
55687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55688       };
55689     } catch (std::exception& e) {
55690       {
55691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55696       };
55697     }
55698   }
55699   jresult = SWIG_csharp_string_callback((&result)->c_str());
55700   return jresult;
55701 }
55702
55703
55704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55705   Dali::Application *arg1 = (Dali::Application *) 0 ;
55706   Dali::ViewMode arg2 ;
55707
55708   arg1 = (Dali::Application *)jarg1;
55709   arg2 = (Dali::ViewMode)jarg2;
55710   {
55711     try {
55712       (arg1)->SetViewMode(arg2);
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (...) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55724       };
55725     }
55726   }
55727 }
55728
55729
55730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55731   int jresult ;
55732   Dali::Application *arg1 = (Dali::Application *) 0 ;
55733   Dali::ViewMode result;
55734
55735   arg1 = (Dali::Application *)jarg1;
55736   {
55737     try {
55738       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55739     } catch (std::out_of_range& e) {
55740       {
55741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (std::exception& e) {
55744       {
55745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (...) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55750       };
55751     }
55752   }
55753   jresult = (int)result;
55754   return jresult;
55755 }
55756
55757
55758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55759   Dali::Application *arg1 = (Dali::Application *) 0 ;
55760   float arg2 ;
55761
55762   arg1 = (Dali::Application *)jarg1;
55763   arg2 = (float)jarg2;
55764   {
55765     try {
55766       (arg1)->SetStereoBase(arg2);
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (...) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55778       };
55779     }
55780   }
55781 }
55782
55783
55784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55785   float jresult ;
55786   Dali::Application *arg1 = (Dali::Application *) 0 ;
55787   float result;
55788
55789   arg1 = (Dali::Application *)jarg1;
55790   {
55791     try {
55792       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55793     } catch (std::out_of_range& e) {
55794       {
55795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (std::exception& e) {
55798       {
55799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (...) {
55802       {
55803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55804       };
55805     }
55806   }
55807   jresult = result;
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55813   void * jresult ;
55814   Dali::Application *arg1 = (Dali::Application *) 0 ;
55815   Dali::Application::AppSignalType *result = 0 ;
55816
55817   arg1 = (Dali::Application *)jarg1;
55818   {
55819     try {
55820       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55821     } catch (std::out_of_range& e) {
55822       {
55823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (std::exception& e) {
55826       {
55827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55832       };
55833     }
55834   }
55835   jresult = (void *)result;
55836   return jresult;
55837 }
55838
55839
55840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55841   void * jresult ;
55842   Dali::Application *arg1 = (Dali::Application *) 0 ;
55843   Dali::Application::AppSignalType *result = 0 ;
55844
55845   arg1 = (Dali::Application *)jarg1;
55846   {
55847     try {
55848       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55849     } catch (std::out_of_range& e) {
55850       {
55851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55852       };
55853     } catch (std::exception& e) {
55854       {
55855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55856       };
55857     } catch (...) {
55858       {
55859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55860       };
55861     }
55862   }
55863   jresult = (void *)result;
55864   return jresult;
55865 }
55866
55867
55868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55869   void * jresult ;
55870   Dali::Application *arg1 = (Dali::Application *) 0 ;
55871   Dali::Application::AppSignalType *result = 0 ;
55872
55873   arg1 = (Dali::Application *)jarg1;
55874   {
55875     try {
55876       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55877     } catch (std::out_of_range& e) {
55878       {
55879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55880       };
55881     } catch (std::exception& e) {
55882       {
55883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (...) {
55886       {
55887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55888       };
55889     }
55890   }
55891   jresult = (void *)result;
55892   return jresult;
55893 }
55894
55895
55896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55897   void * jresult ;
55898   Dali::Application *arg1 = (Dali::Application *) 0 ;
55899   Dali::Application::AppSignalType *result = 0 ;
55900
55901   arg1 = (Dali::Application *)jarg1;
55902   {
55903     try {
55904       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55905     } catch (std::out_of_range& e) {
55906       {
55907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55908       };
55909     } catch (std::exception& e) {
55910       {
55911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (...) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55916       };
55917     }
55918   }
55919   jresult = (void *)result;
55920   return jresult;
55921 }
55922
55923
55924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55925   void * jresult ;
55926   Dali::Application *arg1 = (Dali::Application *) 0 ;
55927   Dali::Application::AppSignalType *result = 0 ;
55928
55929   arg1 = (Dali::Application *)jarg1;
55930   {
55931     try {
55932       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55933     } catch (std::out_of_range& e) {
55934       {
55935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55936       };
55937     } catch (std::exception& e) {
55938       {
55939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (...) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55944       };
55945     }
55946   }
55947   jresult = (void *)result;
55948   return jresult;
55949 }
55950
55951
55952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55953   void * jresult ;
55954   Dali::Application *arg1 = (Dali::Application *) 0 ;
55955   Dali::Application::AppSignalType *result = 0 ;
55956
55957   arg1 = (Dali::Application *)jarg1;
55958   {
55959     try {
55960       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (...) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55972       };
55973     }
55974   }
55975   jresult = (void *)result;
55976   return jresult;
55977 }
55978
55979
55980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55981   void * jresult ;
55982   Dali::Application *arg1 = (Dali::Application *) 0 ;
55983   Dali::Application::AppControlSignalType *result = 0 ;
55984
55985   arg1 = (Dali::Application *)jarg1;
55986   {
55987     try {
55988       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55989     } catch (std::out_of_range& e) {
55990       {
55991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55992       };
55993     } catch (std::exception& e) {
55994       {
55995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55996       };
55997     } catch (...) {
55998       {
55999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56000       };
56001     }
56002   }
56003   jresult = (void *)result;
56004   return jresult;
56005 }
56006
56007
56008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
56009   void * jresult ;
56010   Dali::Application *arg1 = (Dali::Application *) 0 ;
56011   Dali::Application::AppSignalType *result = 0 ;
56012
56013   arg1 = (Dali::Application *)jarg1;
56014   {
56015     try {
56016       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56017     } catch (std::out_of_range& e) {
56018       {
56019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (std::exception& e) {
56022       {
56023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56028       };
56029     }
56030   }
56031   jresult = (void *)result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
56037   void * jresult ;
56038   Dali::Application *arg1 = (Dali::Application *) 0 ;
56039   Dali::Application::AppSignalType *result = 0 ;
56040
56041   arg1 = (Dali::Application *)jarg1;
56042   {
56043     try {
56044       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (...) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56056       };
56057     }
56058   }
56059   jresult = (void *)result;
56060   return jresult;
56061 }
56062
56063
56064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
56065   void * jresult ;
56066   Dali::Application *arg1 = (Dali::Application *) 0 ;
56067   Dali::Application::AppSignalType *result = 0 ;
56068
56069   arg1 = (Dali::Application *)jarg1;
56070   {
56071     try {
56072       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56073     } catch (std::out_of_range& e) {
56074       {
56075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56076       };
56077     } catch (std::exception& e) {
56078       {
56079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (...) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56084       };
56085     }
56086   }
56087   jresult = (void *)result;
56088   return jresult;
56089 }
56090
56091
56092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56093   void * jresult ;
56094   Dali::Application *arg1 = (Dali::Application *) 0 ;
56095   Dali::Application::AppSignalType *result = 0 ;
56096
56097   arg1 = (Dali::Application *)jarg1;
56098   {
56099     try {
56100       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (...) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56112       };
56113     }
56114   }
56115   jresult = (void *)result;
56116   return jresult;
56117 }
56118
56119
56120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56121   unsigned int jresult ;
56122   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56123   bool result;
56124
56125   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56126   {
56127     try {
56128       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56129     } catch (std::out_of_range& e) {
56130       {
56131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56132       };
56133     } catch (std::exception& e) {
56134       {
56135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (...) {
56138       {
56139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56140       };
56141     }
56142   }
56143   jresult = result;
56144   return jresult;
56145 }
56146
56147
56148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56149   unsigned long jresult ;
56150   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56151   std::size_t result;
56152
56153   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56154   {
56155     try {
56156       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56157     } catch (std::out_of_range& e) {
56158       {
56159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56160       };
56161     } catch (std::exception& e) {
56162       {
56163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56164       };
56165     } catch (...) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56168       };
56169     }
56170   }
56171   jresult = (unsigned long)result;
56172   return jresult;
56173 }
56174
56175
56176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56177   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56178   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56179
56180   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56181   arg2 = (void (*)(Dali::Application &))jarg2;
56182   {
56183     try {
56184       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56196       };
56197     }
56198   }
56199 }
56200
56201
56202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56203   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56204   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56205
56206   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56207   arg2 = (void (*)(Dali::Application &))jarg2;
56208   {
56209     try {
56210       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56211     } catch (std::out_of_range& e) {
56212       {
56213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (std::exception& e) {
56216       {
56217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56222       };
56223     }
56224   }
56225 }
56226
56227
56228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56229   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56230   Dali::Application *arg2 = 0 ;
56231
56232   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56233   arg2 = (Dali::Application *)jarg2;
56234   if (!arg2) {
56235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56236     return ;
56237   }
56238   {
56239     try {
56240       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56241     } catch (std::out_of_range& e) {
56242       {
56243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56244       };
56245     } catch (std::exception& e) {
56246       {
56247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56252       };
56253     }
56254   }
56255 }
56256
56257
56258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56259   void * jresult ;
56260   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56261
56262   {
56263     try {
56264       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56265     } catch (std::out_of_range& e) {
56266       {
56267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (std::exception& e) {
56270       {
56271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279   jresult = (void *)result;
56280   return jresult;
56281 }
56282
56283
56284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56285   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56286
56287   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56288   {
56289     try {
56290       delete arg1;
56291     } catch (std::out_of_range& e) {
56292       {
56293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56294       };
56295     } catch (std::exception& e) {
56296       {
56297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56298       };
56299     } catch (...) {
56300       {
56301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56302       };
56303     }
56304   }
56305 }
56306
56307
56308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56309   unsigned int jresult ;
56310   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56311   bool result;
56312
56313   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56314   {
56315     try {
56316       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56317     } catch (std::out_of_range& e) {
56318       {
56319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56320       };
56321     } catch (std::exception& e) {
56322       {
56323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56328       };
56329     }
56330   }
56331   jresult = result;
56332   return jresult;
56333 }
56334
56335
56336 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56337   unsigned long jresult ;
56338   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56339   std::size_t result;
56340
56341   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56342   {
56343     try {
56344       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56345     } catch (std::out_of_range& e) {
56346       {
56347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (std::exception& e) {
56350       {
56351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56352       };
56353     } catch (...) {
56354       {
56355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56356       };
56357     }
56358   }
56359   jresult = (unsigned long)result;
56360   return jresult;
56361 }
56362
56363
56364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56365   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56366   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56367
56368   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56369   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56370   {
56371     try {
56372       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56373     } catch (std::out_of_range& e) {
56374       {
56375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56376       };
56377     } catch (std::exception& e) {
56378       {
56379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56380       };
56381     } catch (...) {
56382       {
56383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56384       };
56385     }
56386   }
56387 }
56388
56389
56390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56391   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56392   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56393
56394   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56395   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56396   {
56397     try {
56398       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56410       };
56411     }
56412   }
56413 }
56414
56415
56416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56417   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56418   Dali::Application *arg2 = 0 ;
56419   void *arg3 = (void *) 0 ;
56420
56421   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56422   arg2 = (Dali::Application *)jarg2;
56423   if (!arg2) {
56424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56425     return ;
56426   }
56427   arg3 = jarg3;
56428   {
56429     try {
56430       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56431     } catch (std::out_of_range& e) {
56432       {
56433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56434       };
56435     } catch (std::exception& e) {
56436       {
56437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56442       };
56443     }
56444   }
56445 }
56446
56447
56448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56449   void * jresult ;
56450   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56451
56452   {
56453     try {
56454       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56466       };
56467     }
56468   }
56469   jresult = (void *)result;
56470   return jresult;
56471 }
56472
56473
56474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56475   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56476
56477   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56478   {
56479     try {
56480       delete arg1;
56481     } catch (std::out_of_range& e) {
56482       {
56483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56484       };
56485     } catch (std::exception& e) {
56486       {
56487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (...) {
56490       {
56491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56492       };
56493     }
56494   }
56495 }
56496
56497
56498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56499   unsigned int jresult ;
56500   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56501   bool result;
56502
56503   arg1 = (Dali::Signal< bool () > *)jarg1;
56504   {
56505     try {
56506       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56507     } catch (std::out_of_range& e) {
56508       {
56509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56510       };
56511     } catch (std::exception& e) {
56512       {
56513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56514       };
56515     } catch (...) {
56516       {
56517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56518       };
56519     }
56520   }
56521   jresult = result;
56522   return jresult;
56523 }
56524
56525
56526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56527   unsigned long jresult ;
56528   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56529   std::size_t result;
56530
56531   arg1 = (Dali::Signal< bool () > *)jarg1;
56532   {
56533     try {
56534       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56542       };
56543     } catch (...) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56546       };
56547     }
56548   }
56549   jresult = (unsigned long)result;
56550   return jresult;
56551 }
56552
56553
56554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56555   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56556   bool (*arg2)() = (bool (*)()) 0 ;
56557
56558   arg1 = (Dali::Signal< bool () > *)jarg1;
56559   arg2 = (bool (*)())jarg2;
56560   {
56561     try {
56562       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56563     } catch (std::out_of_range& e) {
56564       {
56565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56566       };
56567     } catch (std::exception& e) {
56568       {
56569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56570       };
56571     } catch (...) {
56572       {
56573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56574       };
56575     }
56576   }
56577 }
56578
56579
56580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56581   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56582   bool (*arg2)() = (bool (*)()) 0 ;
56583
56584   arg1 = (Dali::Signal< bool () > *)jarg1;
56585   arg2 = (bool (*)())jarg2;
56586   {
56587     try {
56588       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56589     } catch (std::out_of_range& e) {
56590       {
56591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56592       };
56593     } catch (std::exception& e) {
56594       {
56595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56600       };
56601     }
56602   }
56603 }
56604
56605
56606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56607   unsigned int jresult ;
56608   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56609   bool result;
56610
56611   arg1 = (Dali::Signal< bool () > *)jarg1;
56612   {
56613     try {
56614       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56615     } catch (std::out_of_range& e) {
56616       {
56617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56618       };
56619     } catch (std::exception& e) {
56620       {
56621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56622       };
56623     } catch (...) {
56624       {
56625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56626       };
56627     }
56628   }
56629   jresult = result;
56630   return jresult;
56631 }
56632
56633
56634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56635   void * jresult ;
56636   Dali::Signal< bool () > *result = 0 ;
56637
56638   {
56639     try {
56640       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (...) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56652       };
56653     }
56654   }
56655   jresult = (void *)result;
56656   return jresult;
56657 }
56658
56659
56660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56661   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56662
56663   arg1 = (Dali::Signal< bool () > *)jarg1;
56664   {
56665     try {
56666       delete arg1;
56667     } catch (std::out_of_range& e) {
56668       {
56669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56670       };
56671     } catch (std::exception& e) {
56672       {
56673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56674       };
56675     } catch (...) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56678       };
56679     }
56680   }
56681 }
56682
56683
56684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56685   unsigned int jresult ;
56686   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56687   bool result;
56688
56689   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56690   {
56691     try {
56692       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (...) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56704       };
56705     }
56706   }
56707   jresult = result;
56708   return jresult;
56709 }
56710
56711
56712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56713   unsigned long jresult ;
56714   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56715   std::size_t result;
56716
56717   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56718   {
56719     try {
56720       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56721     } catch (std::out_of_range& e) {
56722       {
56723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56724       };
56725     } catch (std::exception& e) {
56726       {
56727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56732       };
56733     }
56734   }
56735   jresult = (unsigned long)result;
56736   return jresult;
56737 }
56738
56739
56740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56741   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56742   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56743
56744   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56745   arg2 = (void (*)(bool))jarg2;
56746   {
56747     try {
56748       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56749     } catch (std::out_of_range& e) {
56750       {
56751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56752       };
56753     } catch (std::exception& e) {
56754       {
56755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56756       };
56757     } catch (...) {
56758       {
56759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56760       };
56761     }
56762   }
56763 }
56764
56765
56766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56767   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56768   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56769
56770   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56771   arg2 = (void (*)(bool))jarg2;
56772   {
56773     try {
56774       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (...) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56786       };
56787     }
56788   }
56789 }
56790
56791
56792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56793   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56794   bool arg2 ;
56795
56796   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56797   arg2 = jarg2 ? true : false;
56798   {
56799     try {
56800       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56801     } catch (std::out_of_range& e) {
56802       {
56803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56804       };
56805     } catch (std::exception& e) {
56806       {
56807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56808       };
56809     } catch (...) {
56810       {
56811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56812       };
56813     }
56814   }
56815 }
56816
56817
56818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56819   void * jresult ;
56820   Dali::Signal< void (bool) > *result = 0 ;
56821
56822   {
56823     try {
56824       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56825     } catch (std::out_of_range& e) {
56826       {
56827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56828       };
56829     } catch (std::exception& e) {
56830       {
56831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (...) {
56834       {
56835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56836       };
56837     }
56838   }
56839   jresult = (void *)result;
56840   return jresult;
56841 }
56842
56843
56844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56845   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56846
56847   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56848   {
56849     try {
56850       delete arg1;
56851     } catch (std::out_of_range& e) {
56852       {
56853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56854       };
56855     } catch (std::exception& e) {
56856       {
56857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56858       };
56859     } catch (...) {
56860       {
56861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56862       };
56863     }
56864   }
56865 }
56866
56867
56868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56869   int jresult ;
56870   int result;
56871
56872   {
56873     try {
56874       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56875     } catch (std::out_of_range& e) {
56876       {
56877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56878       };
56879     } catch (std::exception& e) {
56880       {
56881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56886       };
56887     }
56888   }
56889   jresult = (int)result;
56890   return jresult;
56891 }
56892
56893
56894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56895   int jresult ;
56896   int result;
56897
56898   {
56899     try {
56900       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56901     } catch (std::out_of_range& e) {
56902       {
56903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56904       };
56905     } catch (std::exception& e) {
56906       {
56907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56908       };
56909     } catch (...) {
56910       {
56911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56912       };
56913     }
56914   }
56915   jresult = (int)result;
56916   return jresult;
56917 }
56918
56919
56920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56921   int jresult ;
56922   int result;
56923
56924   {
56925     try {
56926       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56927     } catch (std::out_of_range& e) {
56928       {
56929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (std::exception& e) {
56932       {
56933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56934       };
56935     } catch (...) {
56936       {
56937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56938       };
56939     }
56940   }
56941   jresult = (int)result;
56942   return jresult;
56943 }
56944
56945
56946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56947   int jresult ;
56948   int result;
56949
56950   {
56951     try {
56952       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56964       };
56965     }
56966   }
56967   jresult = (int)result;
56968   return jresult;
56969 }
56970
56971
56972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56973   int jresult ;
56974   int result;
56975
56976   {
56977     try {
56978       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56979     } catch (std::out_of_range& e) {
56980       {
56981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (std::exception& e) {
56984       {
56985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56986       };
56987     } catch (...) {
56988       {
56989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56990       };
56991     }
56992   }
56993   jresult = (int)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56999   int jresult ;
57000   int result;
57001
57002   {
57003     try {
57004       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57005     } catch (std::out_of_range& e) {
57006       {
57007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (std::exception& e) {
57010       {
57011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019   jresult = (int)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57025   int jresult ;
57026   int result;
57027
57028   {
57029     try {
57030       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57031     } catch (std::out_of_range& e) {
57032       {
57033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (std::exception& e) {
57036       {
57037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57042       };
57043     }
57044   }
57045   jresult = (int)result;
57046   return jresult;
57047 }
57048
57049
57050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57051   int jresult ;
57052   int result;
57053
57054   {
57055     try {
57056       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57057     } catch (std::out_of_range& e) {
57058       {
57059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57060       };
57061     } catch (std::exception& e) {
57062       {
57063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57064       };
57065     } catch (...) {
57066       {
57067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57068       };
57069     }
57070   }
57071   jresult = (int)result;
57072   return jresult;
57073 }
57074
57075
57076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57077   int jresult ;
57078   int result;
57079
57080   {
57081     try {
57082       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57083     } catch (std::out_of_range& e) {
57084       {
57085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (std::exception& e) {
57088       {
57089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57090       };
57091     } catch (...) {
57092       {
57093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57094       };
57095     }
57096   }
57097   jresult = (int)result;
57098   return jresult;
57099 }
57100
57101
57102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57103   int jresult ;
57104   int result;
57105
57106   {
57107     try {
57108       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57109     } catch (std::out_of_range& e) {
57110       {
57111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (std::exception& e) {
57114       {
57115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57116       };
57117     } catch (...) {
57118       {
57119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57120       };
57121     }
57122   }
57123   jresult = (int)result;
57124   return jresult;
57125 }
57126
57127
57128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57129   int jresult ;
57130   int result;
57131
57132   {
57133     try {
57134       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57135     } catch (std::out_of_range& e) {
57136       {
57137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (std::exception& e) {
57140       {
57141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57142       };
57143     } catch (...) {
57144       {
57145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57146       };
57147     }
57148   }
57149   jresult = (int)result;
57150   return jresult;
57151 }
57152
57153
57154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57155   int jresult ;
57156   int result;
57157
57158   {
57159     try {
57160       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57161     } catch (std::out_of_range& e) {
57162       {
57163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (std::exception& e) {
57166       {
57167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57168       };
57169     } catch (...) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57172       };
57173     }
57174   }
57175   jresult = (int)result;
57176   return jresult;
57177 }
57178
57179
57180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57181   int jresult ;
57182   int result;
57183
57184   {
57185     try {
57186       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57187     } catch (std::out_of_range& e) {
57188       {
57189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (std::exception& e) {
57192       {
57193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57194       };
57195     } catch (...) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57198       };
57199     }
57200   }
57201   jresult = (int)result;
57202   return jresult;
57203 }
57204
57205
57206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57207   int jresult ;
57208   int result;
57209
57210   {
57211     try {
57212       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57213     } catch (std::out_of_range& e) {
57214       {
57215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57216       };
57217     } catch (std::exception& e) {
57218       {
57219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57220       };
57221     } catch (...) {
57222       {
57223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57224       };
57225     }
57226   }
57227   jresult = (int)result;
57228   return jresult;
57229 }
57230
57231
57232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57233   int jresult ;
57234   int result;
57235
57236   {
57237     try {
57238       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57239     } catch (std::out_of_range& e) {
57240       {
57241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57242       };
57243     } catch (std::exception& e) {
57244       {
57245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57246       };
57247     } catch (...) {
57248       {
57249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57250       };
57251     }
57252   }
57253   jresult = (int)result;
57254   return jresult;
57255 }
57256
57257
57258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57259   int jresult ;
57260   int result;
57261
57262   {
57263     try {
57264       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57265     } catch (std::out_of_range& e) {
57266       {
57267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (std::exception& e) {
57270       {
57271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57276       };
57277     }
57278   }
57279   jresult = (int)result;
57280   return jresult;
57281 }
57282
57283
57284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57285   int jresult ;
57286   int result;
57287
57288   {
57289     try {
57290       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57291     } catch (std::out_of_range& e) {
57292       {
57293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57294       };
57295     } catch (std::exception& e) {
57296       {
57297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57298       };
57299     } catch (...) {
57300       {
57301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57302       };
57303     }
57304   }
57305   jresult = (int)result;
57306   return jresult;
57307 }
57308
57309
57310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57311   int jresult ;
57312   int result;
57313
57314   {
57315     try {
57316       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57317     } catch (std::out_of_range& e) {
57318       {
57319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (std::exception& e) {
57322       {
57323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57328       };
57329     }
57330   }
57331   jresult = (int)result;
57332   return jresult;
57333 }
57334
57335
57336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57337   int jresult ;
57338   int result;
57339
57340   {
57341     try {
57342       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57343     } catch (std::out_of_range& e) {
57344       {
57345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57346       };
57347     } catch (std::exception& e) {
57348       {
57349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57350       };
57351     } catch (...) {
57352       {
57353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57354       };
57355     }
57356   }
57357   jresult = (int)result;
57358   return jresult;
57359 }
57360
57361
57362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57363   int jresult ;
57364   int result;
57365
57366   {
57367     try {
57368       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57369     } catch (std::out_of_range& e) {
57370       {
57371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (std::exception& e) {
57374       {
57375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (...) {
57378       {
57379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57380       };
57381     }
57382   }
57383   jresult = (int)result;
57384   return jresult;
57385 }
57386
57387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57388   int jresult ;
57389   int result;
57390
57391   {
57392     try {
57393       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
57394     } catch (std::out_of_range& e) {
57395       {
57396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57397       };
57398     } catch (std::exception& e) {
57399       {
57400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57401       };
57402     } catch (...) {
57403       {
57404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57405       };
57406     }
57407   }
57408   jresult = (int)result;
57409   return jresult;
57410 }
57411
57412
57413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57414   int jresult ;
57415   int result;
57416
57417   {
57418     try {
57419       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57420     } catch (std::out_of_range& e) {
57421       {
57422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (std::exception& e) {
57425       {
57426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57427       };
57428     } catch (...) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57431       };
57432     }
57433   }
57434   jresult = (int)result;
57435   return jresult;
57436 }
57437
57438
57439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57440   int jresult ;
57441   int result;
57442
57443   {
57444     try {
57445       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57446     } catch (std::out_of_range& e) {
57447       {
57448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (std::exception& e) {
57451       {
57452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57453       };
57454     } catch (...) {
57455       {
57456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57457       };
57458     }
57459   }
57460   jresult = (int)result;
57461   return jresult;
57462 }
57463
57464
57465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57466   int jresult ;
57467   int result;
57468
57469   {
57470     try {
57471       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57472     } catch (std::out_of_range& e) {
57473       {
57474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57475       };
57476     } catch (std::exception& e) {
57477       {
57478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57479       };
57480     } catch (...) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57483       };
57484     }
57485   }
57486   jresult = (int)result;
57487   return jresult;
57488 }
57489
57490
57491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57492   int jresult ;
57493   int result;
57494
57495   {
57496     try {
57497       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57498     } catch (std::out_of_range& e) {
57499       {
57500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (std::exception& e) {
57503       {
57504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57505       };
57506     } catch (...) {
57507       {
57508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57509       };
57510     }
57511   }
57512   jresult = (int)result;
57513   return jresult;
57514 }
57515
57516
57517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57518   int jresult ;
57519   int result;
57520
57521   {
57522     try {
57523       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57524     } catch (std::out_of_range& e) {
57525       {
57526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (std::exception& e) {
57529       {
57530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (...) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57535       };
57536     }
57537   }
57538   jresult = (int)result;
57539   return jresult;
57540 }
57541
57542
57543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57544   int jresult ;
57545   int result;
57546
57547   {
57548     try {
57549       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (...) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57561       };
57562     }
57563   }
57564   jresult = (int)result;
57565   return jresult;
57566 }
57567
57568
57569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57570   int jresult ;
57571   int result;
57572
57573   {
57574     try {
57575       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57576     } catch (std::out_of_range& e) {
57577       {
57578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (std::exception& e) {
57581       {
57582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57583       };
57584     } catch (...) {
57585       {
57586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57587       };
57588     }
57589   }
57590   jresult = (int)result;
57591   return jresult;
57592 }
57593
57594
57595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57596   int jresult ;
57597   int result;
57598
57599   {
57600     try {
57601       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57602     } catch (std::out_of_range& e) {
57603       {
57604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (std::exception& e) {
57607       {
57608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57609       };
57610     } catch (...) {
57611       {
57612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57613       };
57614     }
57615   }
57616   jresult = (int)result;
57617   return jresult;
57618 }
57619
57620
57621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57622   int jresult ;
57623   int result;
57624
57625   {
57626     try {
57627       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57628     } catch (std::out_of_range& e) {
57629       {
57630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57631       };
57632     } catch (std::exception& e) {
57633       {
57634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57635       };
57636     } catch (...) {
57637       {
57638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57639       };
57640     }
57641   }
57642   jresult = (int)result;
57643   return jresult;
57644 }
57645
57646
57647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57648   int jresult ;
57649   int result;
57650
57651   {
57652     try {
57653       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57661       };
57662     } catch (...) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57665       };
57666     }
57667   }
57668   jresult = (int)result;
57669   return jresult;
57670 }
57671
57672
57673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57674   int jresult ;
57675   int result;
57676
57677   {
57678     try {
57679       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57680     } catch (std::out_of_range& e) {
57681       {
57682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57683       };
57684     } catch (std::exception& e) {
57685       {
57686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57687       };
57688     } catch (...) {
57689       {
57690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57691       };
57692     }
57693   }
57694   jresult = (int)result;
57695   return jresult;
57696 }
57697
57698
57699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57700   int jresult ;
57701   int result;
57702
57703   {
57704     try {
57705       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (...) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57717       };
57718     }
57719   }
57720   jresult = (int)result;
57721   return jresult;
57722 }
57723
57724
57725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57726   int jresult ;
57727   int result;
57728
57729   {
57730     try {
57731       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57732     } catch (std::out_of_range& e) {
57733       {
57734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (std::exception& e) {
57737       {
57738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (...) {
57741       {
57742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57743       };
57744     }
57745   }
57746   jresult = (int)result;
57747   return jresult;
57748 }
57749
57750
57751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57752   int jresult ;
57753   int result;
57754
57755   {
57756     try {
57757       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57758     } catch (std::out_of_range& e) {
57759       {
57760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (std::exception& e) {
57763       {
57764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57765       };
57766     } catch (...) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57769       };
57770     }
57771   }
57772   jresult = (int)result;
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57778   int jresult ;
57779   int result;
57780
57781   {
57782     try {
57783       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57784     } catch (std::out_of_range& e) {
57785       {
57786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (std::exception& e) {
57789       {
57790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (...) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57795       };
57796     }
57797   }
57798   jresult = (int)result;
57799   return jresult;
57800 }
57801
57802
57803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57804   int jresult ;
57805   int result;
57806
57807   {
57808     try {
57809       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57810     } catch (std::out_of_range& e) {
57811       {
57812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57813       };
57814     } catch (std::exception& e) {
57815       {
57816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57817       };
57818     } catch (...) {
57819       {
57820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57821       };
57822     }
57823   }
57824   jresult = (int)result;
57825   return jresult;
57826 }
57827
57828
57829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57830   int jresult ;
57831   int result;
57832
57833   {
57834     try {
57835       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57836     } catch (std::out_of_range& e) {
57837       {
57838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (std::exception& e) {
57841       {
57842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (...) {
57845       {
57846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57847       };
57848     }
57849   }
57850   jresult = (int)result;
57851   return jresult;
57852 }
57853
57854
57855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57856   int jresult ;
57857   int result;
57858
57859   {
57860     try {
57861       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57862     } catch (std::out_of_range& e) {
57863       {
57864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57865       };
57866     } catch (std::exception& e) {
57867       {
57868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57869       };
57870     } catch (...) {
57871       {
57872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57873       };
57874     }
57875   }
57876   jresult = (int)result;
57877   return jresult;
57878 }
57879
57880
57881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57882   int jresult ;
57883   int result;
57884
57885   {
57886     try {
57887       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57888     } catch (std::out_of_range& e) {
57889       {
57890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (std::exception& e) {
57893       {
57894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57899       };
57900     }
57901   }
57902   jresult = (int)result;
57903   return jresult;
57904 }
57905
57906
57907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57908   int jresult ;
57909   int result;
57910
57911   {
57912     try {
57913       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57914     } catch (std::out_of_range& e) {
57915       {
57916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (std::exception& e) {
57919       {
57920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (...) {
57923       {
57924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57925       };
57926     }
57927   }
57928   jresult = (int)result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57934   int jresult ;
57935   int result;
57936
57937   {
57938     try {
57939       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57940     } catch (std::out_of_range& e) {
57941       {
57942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (std::exception& e) {
57945       {
57946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57947       };
57948     } catch (...) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57951       };
57952     }
57953   }
57954   jresult = (int)result;
57955   return jresult;
57956 }
57957
57958
57959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57960   int jresult ;
57961   int result;
57962
57963   {
57964     try {
57965       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57966     } catch (std::out_of_range& e) {
57967       {
57968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (std::exception& e) {
57971       {
57972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57973       };
57974     } catch (...) {
57975       {
57976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57977       };
57978     }
57979   }
57980   jresult = (int)result;
57981   return jresult;
57982 }
57983
57984
57985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57986   int jresult ;
57987   int result;
57988
57989   {
57990     try {
57991       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57992     } catch (std::out_of_range& e) {
57993       {
57994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (std::exception& e) {
57997       {
57998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57999       };
58000     } catch (...) {
58001       {
58002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58003       };
58004     }
58005   }
58006   jresult = (int)result;
58007   return jresult;
58008 }
58009
58010
58011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58012   int jresult ;
58013   int result;
58014
58015   {
58016     try {
58017       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58018     } catch (std::out_of_range& e) {
58019       {
58020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (std::exception& e) {
58023       {
58024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58025       };
58026     } catch (...) {
58027       {
58028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58029       };
58030     }
58031   }
58032   jresult = (int)result;
58033   return jresult;
58034 }
58035
58036
58037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58038   int jresult ;
58039   int result;
58040
58041   {
58042     try {
58043       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58051       };
58052     } catch (...) {
58053       {
58054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58055       };
58056     }
58057   }
58058   jresult = (int)result;
58059   return jresult;
58060 }
58061
58062
58063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58064   int jresult ;
58065   int result;
58066
58067   {
58068     try {
58069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58070     } catch (std::out_of_range& e) {
58071       {
58072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (std::exception& e) {
58075       {
58076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58077       };
58078     } catch (...) {
58079       {
58080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58081       };
58082     }
58083   }
58084   jresult = (int)result;
58085   return jresult;
58086 }
58087
58088
58089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58090   int jresult ;
58091   int result;
58092
58093   {
58094     try {
58095       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58096     } catch (std::out_of_range& e) {
58097       {
58098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58099       };
58100     } catch (std::exception& e) {
58101       {
58102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58103       };
58104     } catch (...) {
58105       {
58106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58107       };
58108     }
58109   }
58110   jresult = (int)result;
58111   return jresult;
58112 }
58113
58114
58115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58116   int jresult ;
58117   int result;
58118
58119   {
58120     try {
58121       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58122     } catch (std::out_of_range& e) {
58123       {
58124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (std::exception& e) {
58127       {
58128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58129       };
58130     } catch (...) {
58131       {
58132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58133       };
58134     }
58135   }
58136   jresult = (int)result;
58137   return jresult;
58138 }
58139
58140
58141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58142   int jresult ;
58143   int result;
58144
58145   {
58146     try {
58147       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58148     } catch (std::out_of_range& e) {
58149       {
58150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (std::exception& e) {
58153       {
58154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58155       };
58156     } catch (...) {
58157       {
58158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58159       };
58160     }
58161   }
58162   jresult = (int)result;
58163   return jresult;
58164 }
58165
58166
58167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58168   int jresult ;
58169   int result;
58170
58171   {
58172     try {
58173       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58174     } catch (std::out_of_range& e) {
58175       {
58176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (std::exception& e) {
58179       {
58180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58181       };
58182     } catch (...) {
58183       {
58184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58185       };
58186     }
58187   }
58188   jresult = (int)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58194   int jresult ;
58195   int result;
58196
58197   {
58198     try {
58199       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58200     } catch (std::out_of_range& e) {
58201       {
58202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (std::exception& e) {
58205       {
58206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58207       };
58208     } catch (...) {
58209       {
58210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58211       };
58212     }
58213   }
58214   jresult = (int)result;
58215   return jresult;
58216 }
58217
58218
58219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58220   int jresult ;
58221   int result;
58222
58223   {
58224     try {
58225       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58226     } catch (std::out_of_range& e) {
58227       {
58228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (std::exception& e) {
58231       {
58232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58233       };
58234     } catch (...) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58237       };
58238     }
58239   }
58240   jresult = (int)result;
58241   return jresult;
58242 }
58243
58244
58245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58246   int jresult ;
58247   int result;
58248
58249   {
58250     try {
58251       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (...) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58263       };
58264     }
58265   }
58266   jresult = (int)result;
58267   return jresult;
58268 }
58269
58270
58271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58272   int jresult ;
58273   int result;
58274
58275   {
58276     try {
58277       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58278     } catch (std::out_of_range& e) {
58279       {
58280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (std::exception& e) {
58283       {
58284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58285       };
58286     } catch (...) {
58287       {
58288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58289       };
58290     }
58291   }
58292   jresult = (int)result;
58293   return jresult;
58294 }
58295
58296
58297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58298   int jresult ;
58299   int result;
58300
58301   {
58302     try {
58303       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58304     } catch (std::out_of_range& e) {
58305       {
58306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (std::exception& e) {
58309       {
58310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58311       };
58312     } catch (...) {
58313       {
58314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58315       };
58316     }
58317   }
58318   jresult = (int)result;
58319   return jresult;
58320 }
58321
58322
58323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58324   int jresult ;
58325   int result;
58326
58327   {
58328     try {
58329       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58330     } catch (std::out_of_range& e) {
58331       {
58332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (std::exception& e) {
58335       {
58336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58337       };
58338     } catch (...) {
58339       {
58340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58341       };
58342     }
58343   }
58344   jresult = (int)result;
58345   return jresult;
58346 }
58347
58348
58349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58350   int jresult ;
58351   int result;
58352
58353   {
58354     try {
58355       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (...) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58367       };
58368     }
58369   }
58370   jresult = (int)result;
58371   return jresult;
58372 }
58373
58374
58375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58376   void * jresult ;
58377   Dali::Toolkit::Builder *result = 0 ;
58378
58379   {
58380     try {
58381       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58382     } catch (std::out_of_range& e) {
58383       {
58384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (std::exception& e) {
58387       {
58388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (...) {
58391       {
58392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58393       };
58394     }
58395   }
58396   jresult = (void *)result;
58397   return jresult;
58398 }
58399
58400
58401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58402   void * jresult ;
58403   Dali::Toolkit::Builder result;
58404
58405   {
58406     try {
58407       result = Dali::Toolkit::Builder::New();
58408     } catch (std::out_of_range& e) {
58409       {
58410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (std::exception& e) {
58413       {
58414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58415       };
58416     } catch (...) {
58417       {
58418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58419       };
58420     }
58421   }
58422   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58423   return jresult;
58424 }
58425
58426
58427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58428   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58429
58430   arg1 = (Dali::Toolkit::Builder *)jarg1;
58431   {
58432     try {
58433       delete arg1;
58434     } catch (std::out_of_range& e) {
58435       {
58436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58437       };
58438     } catch (std::exception& e) {
58439       {
58440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58445       };
58446     }
58447   }
58448 }
58449
58450
58451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58452   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58453   std::string *arg2 = 0 ;
58454   Dali::Toolkit::Builder::UIFormat arg3 ;
58455
58456   arg1 = (Dali::Toolkit::Builder *)jarg1;
58457   if (!jarg2) {
58458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58459     return ;
58460   }
58461   std::string arg2_str(jarg2);
58462   arg2 = &arg2_str;
58463   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58464   {
58465     try {
58466       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58467     } catch (std::out_of_range& e) {
58468       {
58469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58470       };
58471     } catch (std::exception& e) {
58472       {
58473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58474       };
58475     } catch (...) {
58476       {
58477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58478       };
58479     }
58480   }
58481
58482   //argout typemap for const std::string&
58483
58484 }
58485
58486
58487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58488   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58489   std::string *arg2 = 0 ;
58490
58491   arg1 = (Dali::Toolkit::Builder *)jarg1;
58492   if (!jarg2) {
58493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58494     return ;
58495   }
58496   std::string arg2_str(jarg2);
58497   arg2 = &arg2_str;
58498   {
58499     try {
58500       (arg1)->LoadFromString((std::string const &)*arg2);
58501     } catch (std::out_of_range& e) {
58502       {
58503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58504       };
58505     } catch (std::exception& e) {
58506       {
58507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58508       };
58509     } catch (...) {
58510       {
58511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58512       };
58513     }
58514   }
58515
58516   //argout typemap for const std::string&
58517
58518 }
58519
58520
58521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58522   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58523   Dali::Property::Map *arg2 = 0 ;
58524
58525   arg1 = (Dali::Toolkit::Builder *)jarg1;
58526   arg2 = (Dali::Property::Map *)jarg2;
58527   if (!arg2) {
58528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58529     return ;
58530   }
58531   {
58532     try {
58533       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58534     } catch (std::out_of_range& e) {
58535       {
58536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58537       };
58538     } catch (std::exception& e) {
58539       {
58540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58541       };
58542     } catch (...) {
58543       {
58544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58545       };
58546     }
58547   }
58548 }
58549
58550
58551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58553   std::string *arg2 = 0 ;
58554   Dali::Property::Value *arg3 = 0 ;
58555
58556   arg1 = (Dali::Toolkit::Builder *)jarg1;
58557   if (!jarg2) {
58558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58559     return ;
58560   }
58561   std::string arg2_str(jarg2);
58562   arg2 = &arg2_str;
58563   arg3 = (Dali::Property::Value *)jarg3;
58564   if (!arg3) {
58565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58566     return ;
58567   }
58568   {
58569     try {
58570       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58578       };
58579     } catch (...) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58582       };
58583     }
58584   }
58585
58586   //argout typemap for const std::string&
58587
58588 }
58589
58590
58591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58592   void * jresult ;
58593   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58594   Dali::Property::Map *result = 0 ;
58595
58596   arg1 = (Dali::Toolkit::Builder *)jarg1;
58597   {
58598     try {
58599       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58600     } catch (std::out_of_range& e) {
58601       {
58602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58603       };
58604     } catch (std::exception& e) {
58605       {
58606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58607       };
58608     } catch (...) {
58609       {
58610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58611       };
58612     }
58613   }
58614   jresult = (void *)result;
58615   return jresult;
58616 }
58617
58618
58619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58620   void * jresult ;
58621   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58622   std::string *arg2 = 0 ;
58623   Dali::Property::Value *result = 0 ;
58624
58625   arg1 = (Dali::Toolkit::Builder *)jarg1;
58626   if (!jarg2) {
58627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58628     return 0;
58629   }
58630   std::string arg2_str(jarg2);
58631   arg2 = &arg2_str;
58632   {
58633     try {
58634       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58635     } catch (std::out_of_range& e) {
58636       {
58637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58638       };
58639     } catch (std::exception& e) {
58640       {
58641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58646       };
58647     }
58648   }
58649   jresult = (void *)result;
58650
58651   //argout typemap for const std::string&
58652
58653   return jresult;
58654 }
58655
58656
58657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58658   void * jresult ;
58659   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58660   std::string *arg2 = 0 ;
58661   Dali::Animation result;
58662
58663   arg1 = (Dali::Toolkit::Builder *)jarg1;
58664   if (!jarg2) {
58665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58666     return 0;
58667   }
58668   std::string arg2_str(jarg2);
58669   arg2 = &arg2_str;
58670   {
58671     try {
58672       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58673     } catch (std::out_of_range& e) {
58674       {
58675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58676       };
58677     } catch (std::exception& e) {
58678       {
58679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58680       };
58681     } catch (...) {
58682       {
58683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58684       };
58685     }
58686   }
58687   jresult = new Dali::Animation((const Dali::Animation &)result);
58688
58689   //argout typemap for const std::string&
58690
58691   return jresult;
58692 }
58693
58694
58695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58696   void * jresult ;
58697   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58698   std::string *arg2 = 0 ;
58699   Dali::Property::Map *arg3 = 0 ;
58700   Dali::Animation result;
58701
58702   arg1 = (Dali::Toolkit::Builder *)jarg1;
58703   if (!jarg2) {
58704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58705     return 0;
58706   }
58707   std::string arg2_str(jarg2);
58708   arg2 = &arg2_str;
58709   arg3 = (Dali::Property::Map *)jarg3;
58710   if (!arg3) {
58711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58712     return 0;
58713   }
58714   {
58715     try {
58716       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731   jresult = new Dali::Animation((const Dali::Animation &)result);
58732
58733   //argout typemap for const std::string&
58734
58735   return jresult;
58736 }
58737
58738
58739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58740   void * jresult ;
58741   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58742   std::string *arg2 = 0 ;
58743   Dali::Actor arg3 ;
58744   Dali::Actor *argp3 ;
58745   Dali::Animation result;
58746
58747   arg1 = (Dali::Toolkit::Builder *)jarg1;
58748   if (!jarg2) {
58749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58750     return 0;
58751   }
58752   std::string arg2_str(jarg2);
58753   arg2 = &arg2_str;
58754   argp3 = (Dali::Actor *)jarg3;
58755   if (!argp3) {
58756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58757     return 0;
58758   }
58759   arg3 = *argp3;
58760   {
58761     try {
58762       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58763     } catch (std::out_of_range& e) {
58764       {
58765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (std::exception& e) {
58768       {
58769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777   jresult = new Dali::Animation((const Dali::Animation &)result);
58778
58779   //argout typemap for const std::string&
58780
58781   return jresult;
58782 }
58783
58784
58785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58786   void * jresult ;
58787   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58788   std::string *arg2 = 0 ;
58789   Dali::Property::Map *arg3 = 0 ;
58790   Dali::Actor arg4 ;
58791   Dali::Actor *argp4 ;
58792   Dali::Animation result;
58793
58794   arg1 = (Dali::Toolkit::Builder *)jarg1;
58795   if (!jarg2) {
58796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58797     return 0;
58798   }
58799   std::string arg2_str(jarg2);
58800   arg2 = &arg2_str;
58801   arg3 = (Dali::Property::Map *)jarg3;
58802   if (!arg3) {
58803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58804     return 0;
58805   }
58806   argp4 = (Dali::Actor *)jarg4;
58807   if (!argp4) {
58808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58809     return 0;
58810   }
58811   arg4 = *argp4;
58812   {
58813     try {
58814       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58815     } catch (std::out_of_range& e) {
58816       {
58817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (std::exception& e) {
58820       {
58821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58822       };
58823     } catch (...) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58826       };
58827     }
58828   }
58829   jresult = new Dali::Animation((const Dali::Animation &)result);
58830
58831   //argout typemap for const std::string&
58832
58833   return jresult;
58834 }
58835
58836
58837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58838   void * jresult ;
58839   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58840   std::string *arg2 = 0 ;
58841   Dali::BaseHandle result;
58842
58843   arg1 = (Dali::Toolkit::Builder *)jarg1;
58844   if (!jarg2) {
58845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58846     return 0;
58847   }
58848   std::string arg2_str(jarg2);
58849   arg2 = &arg2_str;
58850   {
58851     try {
58852       result = (arg1)->Create((std::string const &)*arg2);
58853     } catch (std::out_of_range& e) {
58854       {
58855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (std::exception& e) {
58858       {
58859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58860       };
58861     } catch (...) {
58862       {
58863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58864       };
58865     }
58866   }
58867   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58868
58869   //argout typemap for const std::string&
58870
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58876   void * jresult ;
58877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58878   std::string *arg2 = 0 ;
58879   Dali::Property::Map *arg3 = 0 ;
58880   Dali::BaseHandle result;
58881
58882   arg1 = (Dali::Toolkit::Builder *)jarg1;
58883   if (!jarg2) {
58884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58885     return 0;
58886   }
58887   std::string arg2_str(jarg2);
58888   arg2 = &arg2_str;
58889   arg3 = (Dali::Property::Map *)jarg3;
58890   if (!arg3) {
58891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58892     return 0;
58893   }
58894   {
58895     try {
58896       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58904       };
58905     } catch (...) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58908       };
58909     }
58910   }
58911   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58912
58913   //argout typemap for const std::string&
58914
58915   return jresult;
58916 }
58917
58918
58919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58920   void * jresult ;
58921   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58922   std::string *arg2 = 0 ;
58923   Dali::BaseHandle result;
58924
58925   arg1 = (Dali::Toolkit::Builder *)jarg1;
58926   if (!jarg2) {
58927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58928     return 0;
58929   }
58930   std::string arg2_str(jarg2);
58931   arg2 = &arg2_str;
58932   {
58933     try {
58934       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58935     } catch (std::out_of_range& e) {
58936       {
58937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58938       };
58939     } catch (std::exception& e) {
58940       {
58941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58942       };
58943     } catch (...) {
58944       {
58945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58946       };
58947     }
58948   }
58949   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58950
58951   //argout typemap for const std::string&
58952
58953   return jresult;
58954 }
58955
58956
58957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58958   unsigned int jresult ;
58959   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58960   std::string *arg2 = 0 ;
58961   Dali::Handle *arg3 = 0 ;
58962   bool result;
58963
58964   arg1 = (Dali::Toolkit::Builder *)jarg1;
58965   if (!jarg2) {
58966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58967     return 0;
58968   }
58969   std::string arg2_str(jarg2);
58970   arg2 = &arg2_str;
58971   arg3 = (Dali::Handle *)jarg3;
58972   if (!arg3) {
58973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58974     return 0;
58975   }
58976   {
58977     try {
58978       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (...) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58990       };
58991     }
58992   }
58993   jresult = result;
58994
58995   //argout typemap for const std::string&
58996
58997   return jresult;
58998 }
58999
59000
59001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59002   unsigned int jresult ;
59003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59004   Dali::Handle *arg2 = 0 ;
59005   std::string *arg3 = 0 ;
59006   bool result;
59007
59008   arg1 = (Dali::Toolkit::Builder *)jarg1;
59009   arg2 = (Dali::Handle *)jarg2;
59010   if (!arg2) {
59011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59012     return 0;
59013   }
59014   if (!jarg3) {
59015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59016     return 0;
59017   }
59018   std::string arg3_str(jarg3);
59019   arg3 = &arg3_str;
59020   {
59021     try {
59022       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59023     } catch (std::out_of_range& e) {
59024       {
59025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59026       };
59027     } catch (std::exception& e) {
59028       {
59029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59030       };
59031     } catch (...) {
59032       {
59033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59034       };
59035     }
59036   }
59037   jresult = result;
59038
59039   //argout typemap for const std::string&
59040
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59046   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59047   Dali::Actor arg2 ;
59048   Dali::Actor *argp2 ;
59049
59050   arg1 = (Dali::Toolkit::Builder *)jarg1;
59051   argp2 = (Dali::Actor *)jarg2;
59052   if (!argp2) {
59053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59054     return ;
59055   }
59056   arg2 = *argp2;
59057   {
59058     try {
59059       (arg1)->AddActors(arg2);
59060     } catch (std::out_of_range& e) {
59061       {
59062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59063       };
59064     } catch (std::exception& e) {
59065       {
59066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59067       };
59068     } catch (...) {
59069       {
59070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59071       };
59072     }
59073   }
59074 }
59075
59076
59077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59078   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59079   std::string *arg2 = 0 ;
59080   Dali::Actor arg3 ;
59081   Dali::Actor *argp3 ;
59082
59083   arg1 = (Dali::Toolkit::Builder *)jarg1;
59084   if (!jarg2) {
59085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59086     return ;
59087   }
59088   std::string arg2_str(jarg2);
59089   arg2 = &arg2_str;
59090   argp3 = (Dali::Actor *)jarg3;
59091   if (!argp3) {
59092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59093     return ;
59094   }
59095   arg3 = *argp3;
59096   {
59097     try {
59098       (arg1)->AddActors((std::string const &)*arg2,arg3);
59099     } catch (std::out_of_range& e) {
59100       {
59101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59102       };
59103     } catch (std::exception& e) {
59104       {
59105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59106       };
59107     } catch (...) {
59108       {
59109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59110       };
59111     }
59112   }
59113
59114   //argout typemap for const std::string&
59115
59116 }
59117
59118
59119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59120   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59121   std::string *arg2 = 0 ;
59122
59123   arg1 = (Dali::Toolkit::Builder *)jarg1;
59124   if (!jarg2) {
59125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59126     return ;
59127   }
59128   std::string arg2_str(jarg2);
59129   arg2 = &arg2_str;
59130   {
59131     try {
59132       (arg1)->CreateRenderTask((std::string const &)*arg2);
59133     } catch (std::out_of_range& e) {
59134       {
59135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (std::exception& e) {
59138       {
59139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59140       };
59141     } catch (...) {
59142       {
59143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59144       };
59145     }
59146   }
59147
59148   //argout typemap for const std::string&
59149
59150 }
59151
59152
59153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59154   void * jresult ;
59155   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59156   std::string *arg2 = 0 ;
59157   Dali::FrameBufferImage result;
59158
59159   arg1 = (Dali::Toolkit::Builder *)jarg1;
59160   if (!jarg2) {
59161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59162     return 0;
59163   }
59164   std::string arg2_str(jarg2);
59165   arg2 = &arg2_str;
59166   {
59167     try {
59168       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59169     } catch (std::out_of_range& e) {
59170       {
59171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (std::exception& e) {
59174       {
59175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (...) {
59178       {
59179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59180       };
59181     }
59182   }
59183   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59184
59185   //argout typemap for const std::string&
59186
59187   return jresult;
59188 }
59189
59190
59191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59192   void * jresult ;
59193   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59194   std::string *arg2 = 0 ;
59195   Dali::Path result;
59196
59197   arg1 = (Dali::Toolkit::Builder *)jarg1;
59198   if (!jarg2) {
59199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59200     return 0;
59201   }
59202   std::string arg2_str(jarg2);
59203   arg2 = &arg2_str;
59204   {
59205     try {
59206       result = (arg1)->GetPath((std::string const &)*arg2);
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59214       };
59215     } catch (...) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59218       };
59219     }
59220   }
59221   jresult = new Dali::Path((const Dali::Path &)result);
59222
59223   //argout typemap for const std::string&
59224
59225   return jresult;
59226 }
59227
59228
59229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59230   void * jresult ;
59231   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59232   std::string *arg2 = 0 ;
59233   Dali::PathConstrainer result;
59234
59235   arg1 = (Dali::Toolkit::Builder *)jarg1;
59236   if (!jarg2) {
59237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59238     return 0;
59239   }
59240   std::string arg2_str(jarg2);
59241   arg2 = &arg2_str;
59242   {
59243     try {
59244       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59245     } catch (std::out_of_range& e) {
59246       {
59247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59248       };
59249     } catch (std::exception& e) {
59250       {
59251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59256       };
59257     }
59258   }
59259   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59260
59261   //argout typemap for const std::string&
59262
59263   return jresult;
59264 }
59265
59266
59267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59268   void * jresult ;
59269   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59270   std::string *arg2 = 0 ;
59271   Dali::LinearConstrainer result;
59272
59273   arg1 = (Dali::Toolkit::Builder *)jarg1;
59274   if (!jarg2) {
59275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59276     return 0;
59277   }
59278   std::string arg2_str(jarg2);
59279   arg2 = &arg2_str;
59280   {
59281     try {
59282       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59283     } catch (std::out_of_range& e) {
59284       {
59285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (std::exception& e) {
59288       {
59289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59290       };
59291     } catch (...) {
59292       {
59293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59294       };
59295     }
59296   }
59297   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59298
59299   //argout typemap for const std::string&
59300
59301   return jresult;
59302 }
59303
59304
59305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59306   void * jresult ;
59307   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59308   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59309
59310   arg1 = (Dali::Toolkit::Builder *)jarg1;
59311   {
59312     try {
59313       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59314     } catch (std::out_of_range& e) {
59315       {
59316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (std::exception& e) {
59319       {
59320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59321       };
59322     } catch (...) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59325       };
59326     }
59327   }
59328   jresult = (void *)result;
59329   return jresult;
59330 }
59331
59332
59333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59334   void * jresult ;
59335   Dali::Toolkit::TransitionData *result = 0 ;
59336
59337   {
59338     try {
59339       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59340     } catch (std::out_of_range& e) {
59341       {
59342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (std::exception& e) {
59345       {
59346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59347       };
59348     } catch (...) {
59349       {
59350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59351       };
59352     }
59353   }
59354   jresult = (void *)result;
59355   return jresult;
59356 }
59357
59358
59359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59360   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59361
59362   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59363   {
59364     try {
59365       delete arg1;
59366     } catch (std::out_of_range& e) {
59367       {
59368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59369       };
59370     } catch (std::exception& e) {
59371       {
59372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59373       };
59374     } catch (...) {
59375       {
59376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59377       };
59378     }
59379   }
59380 }
59381
59382
59383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59384   void * jresult ;
59385   Dali::Property::Map *arg1 = 0 ;
59386   Dali::Toolkit::TransitionData result;
59387
59388   arg1 = (Dali::Property::Map *)jarg1;
59389   if (!arg1) {
59390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59391     return 0;
59392   }
59393   {
59394     try {
59395       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59396     } catch (std::out_of_range& e) {
59397       {
59398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59399       };
59400     } catch (std::exception& e) {
59401       {
59402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59403       };
59404     } catch (...) {
59405       {
59406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59407       };
59408     }
59409   }
59410   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59411   return jresult;
59412 }
59413
59414
59415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59416   void * jresult ;
59417   Dali::Property::Array *arg1 = 0 ;
59418   Dali::Toolkit::TransitionData result;
59419
59420   arg1 = (Dali::Property::Array *)jarg1;
59421   if (!arg1) {
59422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59423     return 0;
59424   }
59425   {
59426     try {
59427       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59428     } catch (std::out_of_range& e) {
59429       {
59430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59431       };
59432     } catch (std::exception& e) {
59433       {
59434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59435       };
59436     } catch (...) {
59437       {
59438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59439       };
59440     }
59441   }
59442   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59443   return jresult;
59444 }
59445
59446
59447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59448   void * jresult ;
59449   Dali::BaseHandle arg1 ;
59450   Dali::BaseHandle *argp1 ;
59451   Dali::Toolkit::TransitionData result;
59452
59453   argp1 = (Dali::BaseHandle *)jarg1;
59454   if (!argp1) {
59455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59456     return 0;
59457   }
59458   arg1 = *argp1;
59459   {
59460     try {
59461       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59462     } catch (std::out_of_range& e) {
59463       {
59464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59465       };
59466     } catch (std::exception& e) {
59467       {
59468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (...) {
59471       {
59472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59473       };
59474     }
59475   }
59476   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59477   return jresult;
59478 }
59479
59480
59481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59482   void * jresult ;
59483   Dali::Toolkit::TransitionData *arg1 = 0 ;
59484   Dali::Toolkit::TransitionData *result = 0 ;
59485
59486   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59487   if (!arg1) {
59488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59489     return 0;
59490   }
59491   {
59492     try {
59493       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59505       };
59506     }
59507   }
59508   jresult = (void *)result;
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59514   void * jresult ;
59515   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59516   Dali::Toolkit::TransitionData *arg2 = 0 ;
59517   Dali::Toolkit::TransitionData *result = 0 ;
59518
59519   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59520   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59521   if (!arg2) {
59522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59523     return 0;
59524   }
59525   {
59526     try {
59527       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (...) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59539       };
59540     }
59541   }
59542   jresult = (void *)result;
59543   return jresult;
59544 }
59545
59546
59547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59548   unsigned long jresult ;
59549   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59550   size_t result;
59551
59552   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59553   {
59554     try {
59555       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59556     } catch (std::out_of_range& e) {
59557       {
59558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59559       };
59560     } catch (std::exception& e) {
59561       {
59562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (...) {
59565       {
59566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59567       };
59568     }
59569   }
59570   jresult = (unsigned long)result;
59571   return jresult;
59572 }
59573
59574
59575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59576   void * jresult ;
59577   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59578   size_t arg2 ;
59579   Dali::Property::Map result;
59580
59581   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59582   arg2 = (size_t)jarg2;
59583   {
59584     try {
59585       result = (arg1)->GetAnimatorAt(arg2);
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (...) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59597       };
59598     }
59599   }
59600   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59601   return jresult;
59602 }
59603
59604
59605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59606   void * jresult ;
59607   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59608   Dali::Toolkit::TransitionData *result = 0 ;
59609
59610   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59611   {
59612     try {
59613       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59614     } catch (std::out_of_range& e) {
59615       {
59616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59617       };
59618     } catch (std::exception& e) {
59619       {
59620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59621       };
59622     } catch (...) {
59623       {
59624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59625       };
59626     }
59627   }
59628   jresult = (void *)result;
59629   return jresult;
59630 }
59631
59632
59633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59634   int jresult ;
59635   int result;
59636
59637   {
59638     try {
59639       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59640     } catch (std::out_of_range& e) {
59641       {
59642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (std::exception& e) {
59645       {
59646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (...) {
59649       {
59650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59651       };
59652     }
59653   }
59654   jresult = (int)result;
59655   return jresult;
59656 }
59657
59658
59659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59660   int jresult ;
59661   int result;
59662
59663   {
59664     try {
59665       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59666     } catch (std::out_of_range& e) {
59667       {
59668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (std::exception& e) {
59671       {
59672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59673       };
59674     } catch (...) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59677       };
59678     }
59679   }
59680   jresult = (int)result;
59681   return jresult;
59682 }
59683
59684
59685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59686   int jresult ;
59687   int result;
59688
59689   {
59690     try {
59691       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59692     } catch (std::out_of_range& e) {
59693       {
59694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (std::exception& e) {
59697       {
59698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706   jresult = (int)result;
59707   return jresult;
59708 }
59709
59710
59711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59712   int jresult ;
59713   int result;
59714
59715   {
59716     try {
59717       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59718     } catch (std::out_of_range& e) {
59719       {
59720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59721       };
59722     } catch (std::exception& e) {
59723       {
59724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59725       };
59726     } catch (...) {
59727       {
59728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59729       };
59730     }
59731   }
59732   jresult = (int)result;
59733   return jresult;
59734 }
59735
59736
59737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59738   int jresult ;
59739   int result;
59740
59741   {
59742     try {
59743       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59744     } catch (std::out_of_range& e) {
59745       {
59746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (std::exception& e) {
59749       {
59750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59751       };
59752     } catch (...) {
59753       {
59754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59755       };
59756     }
59757   }
59758   jresult = (int)result;
59759   return jresult;
59760 }
59761
59762
59763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59764   int jresult ;
59765   int result;
59766
59767   {
59768     try {
59769       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59770     } catch (std::out_of_range& e) {
59771       {
59772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59773       };
59774     } catch (std::exception& e) {
59775       {
59776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (...) {
59779       {
59780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59781       };
59782     }
59783   }
59784   jresult = (int)result;
59785   return jresult;
59786 }
59787
59788
59789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59790   int jresult ;
59791   int result;
59792
59793   {
59794     try {
59795       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59796     } catch (std::out_of_range& e) {
59797       {
59798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (std::exception& e) {
59801       {
59802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59803       };
59804     } catch (...) {
59805       {
59806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59807       };
59808     }
59809   }
59810   jresult = (int)result;
59811   return jresult;
59812 }
59813
59814
59815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59816   int jresult ;
59817   int result;
59818
59819   {
59820     try {
59821       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59822     } catch (std::out_of_range& e) {
59823       {
59824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (std::exception& e) {
59827       {
59828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59829       };
59830     } catch (...) {
59831       {
59832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59833       };
59834     }
59835   }
59836   jresult = (int)result;
59837   return jresult;
59838 }
59839
59840
59841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59842   int jresult ;
59843   int result;
59844
59845   {
59846     try {
59847       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59848     } catch (std::out_of_range& e) {
59849       {
59850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (std::exception& e) {
59853       {
59854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (...) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59859       };
59860     }
59861   }
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866
59867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59868   int jresult ;
59869   int result;
59870
59871   {
59872     try {
59873       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59874     } catch (std::out_of_range& e) {
59875       {
59876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59877       };
59878     } catch (std::exception& e) {
59879       {
59880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59881       };
59882     } catch (...) {
59883       {
59884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59885       };
59886     }
59887   }
59888   jresult = (int)result;
59889   return jresult;
59890 }
59891
59892
59893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59894   int jresult ;
59895   int result;
59896
59897   {
59898     try {
59899       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59900     } catch (std::out_of_range& e) {
59901       {
59902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59903       };
59904     } catch (std::exception& e) {
59905       {
59906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (...) {
59909       {
59910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59911       };
59912     }
59913   }
59914   jresult = (int)result;
59915   return jresult;
59916 }
59917
59918
59919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59920   int jresult ;
59921   int result;
59922
59923   {
59924     try {
59925       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59933       };
59934     } catch (...) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59937       };
59938     }
59939   }
59940   jresult = (int)result;
59941   return jresult;
59942 }
59943
59944
59945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59946   int jresult ;
59947   int result;
59948
59949   {
59950     try {
59951       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59963       };
59964     }
59965   }
59966   jresult = (int)result;
59967   return jresult;
59968 }
59969
59970
59971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59972   int jresult ;
59973   int result;
59974
59975   {
59976     try {
59977       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59978     } catch (std::out_of_range& e) {
59979       {
59980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (std::exception& e) {
59983       {
59984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59985       };
59986     } catch (...) {
59987       {
59988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59989       };
59990     }
59991   }
59992   jresult = (int)result;
59993   return jresult;
59994 }
59995
59996
59997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59998   void * jresult ;
59999   Dali::Toolkit::Control result;
60000
60001   {
60002     try {
60003       result = Dali::Toolkit::Internal::Control::New();
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60019   return jresult;
60020 }
60021
60022
60023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60025   std::string *arg2 = 0 ;
60026
60027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60028   if (!jarg2) {
60029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60030     return ;
60031   }
60032   std::string arg2_str(jarg2);
60033   arg2 = &arg2_str;
60034   {
60035     try {
60036       (arg1)->SetStyleName((std::string const &)*arg2);
60037     } catch (std::out_of_range& e) {
60038       {
60039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60040       };
60041     } catch (std::exception& e) {
60042       {
60043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60044       };
60045     } catch (...) {
60046       {
60047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60048       };
60049     }
60050   }
60051
60052   //argout typemap for const std::string&
60053
60054 }
60055
60056
60057 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60058   char * jresult ;
60059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60060   std::string *result = 0 ;
60061
60062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60063   {
60064     try {
60065       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60066     } catch (std::out_of_range& e) {
60067       {
60068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (std::exception& e) {
60071       {
60072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080   jresult = SWIG_csharp_string_callback(result->c_str());
60081   return jresult;
60082 }
60083
60084
60085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60087   Dali::Vector4 *arg2 = 0 ;
60088
60089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60090   arg2 = (Dali::Vector4 *)jarg2;
60091   if (!arg2) {
60092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60093     return ;
60094   }
60095   {
60096     try {
60097       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60098     } catch (std::out_of_range& e) {
60099       {
60100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60101       };
60102     } catch (std::exception& e) {
60103       {
60104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60105       };
60106     } catch (...) {
60107       {
60108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60109       };
60110     }
60111   }
60112 }
60113
60114
60115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60116   void * jresult ;
60117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60118   Dali::Vector4 result;
60119
60120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60121   {
60122     try {
60123       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (...) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60135       };
60136     }
60137   }
60138   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60139   return jresult;
60140 }
60141
60142
60143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60145   Dali::Image arg2 ;
60146   Dali::Image *argp2 ;
60147
60148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60149   argp2 = (Dali::Image *)jarg2;
60150   if (!argp2) {
60151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60152     return ;
60153   }
60154   arg2 = *argp2;
60155   {
60156     try {
60157       (arg1)->SetBackgroundImage(arg2);
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172 }
60173
60174
60175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60177   Dali::Property::Map *arg2 = 0 ;
60178
60179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60180   arg2 = (Dali::Property::Map *)jarg2;
60181   if (!arg2) {
60182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60183     return ;
60184   }
60185   {
60186     try {
60187       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60188     } catch (std::out_of_range& e) {
60189       {
60190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60191       };
60192     } catch (std::exception& e) {
60193       {
60194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60195       };
60196     } catch (...) {
60197       {
60198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60199       };
60200     }
60201   }
60202 }
60203
60204
60205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60207
60208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60209   {
60210     try {
60211       (arg1)->ClearBackground();
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60219       };
60220     } catch (...) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60223       };
60224     }
60225   }
60226 }
60227
60228
60229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60231   Dali::Gesture::Type arg2 ;
60232
60233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60234   arg2 = (Dali::Gesture::Type)jarg2;
60235   {
60236     try {
60237       (arg1)->EnableGestureDetection(arg2);
60238     } catch (std::out_of_range& e) {
60239       {
60240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60241       };
60242     } catch (std::exception& e) {
60243       {
60244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60245       };
60246     } catch (...) {
60247       {
60248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60249       };
60250     }
60251   }
60252 }
60253
60254
60255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60257   Dali::Gesture::Type arg2 ;
60258
60259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60260   arg2 = (Dali::Gesture::Type)jarg2;
60261   {
60262     try {
60263       (arg1)->DisableGestureDetection(arg2);
60264     } catch (std::out_of_range& e) {
60265       {
60266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (std::exception& e) {
60269       {
60270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (...) {
60273       {
60274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60275       };
60276     }
60277   }
60278 }
60279
60280
60281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60282   void * jresult ;
60283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60284   Dali::PinchGestureDetector result;
60285
60286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60287   {
60288     try {
60289       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60290     } catch (std::out_of_range& e) {
60291       {
60292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60293       };
60294     } catch (std::exception& e) {
60295       {
60296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60297       };
60298     } catch (...) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60301       };
60302     }
60303   }
60304   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60305   return jresult;
60306 }
60307
60308
60309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60310   void * jresult ;
60311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60312   Dali::PanGestureDetector result;
60313
60314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60315   {
60316     try {
60317       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60318     } catch (std::out_of_range& e) {
60319       {
60320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (std::exception& e) {
60323       {
60324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (...) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60329       };
60330     }
60331   }
60332   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60333   return jresult;
60334 }
60335
60336
60337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60338   void * jresult ;
60339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60340   Dali::TapGestureDetector result;
60341
60342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60343   {
60344     try {
60345       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60346     } catch (std::out_of_range& e) {
60347       {
60348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60349       };
60350     } catch (std::exception& e) {
60351       {
60352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60353       };
60354     } catch (...) {
60355       {
60356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60357       };
60358     }
60359   }
60360   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60366   void * jresult ;
60367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60368   Dali::LongPressGestureDetector result;
60369
60370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60371   {
60372     try {
60373       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60395   bool arg2 ;
60396
60397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60398   arg2 = jarg2 ? true : false;
60399   {
60400     try {
60401       (arg1)->SetKeyboardNavigationSupport(arg2);
60402     } catch (std::out_of_range& e) {
60403       {
60404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60405       };
60406     } catch (std::exception& e) {
60407       {
60408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60409       };
60410     } catch (...) {
60411       {
60412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60413       };
60414     }
60415   }
60416 }
60417
60418
60419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60420   unsigned int jresult ;
60421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60422   bool result;
60423
60424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60425   {
60426     try {
60427       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60428     } catch (std::out_of_range& e) {
60429       {
60430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60431       };
60432     } catch (std::exception& e) {
60433       {
60434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (...) {
60437       {
60438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60439       };
60440     }
60441   }
60442   jresult = result;
60443   return jresult;
60444 }
60445
60446
60447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60449
60450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60451   {
60452     try {
60453       (arg1)->SetKeyInputFocus();
60454     } catch (std::out_of_range& e) {
60455       {
60456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60457       };
60458     } catch (std::exception& e) {
60459       {
60460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60461       };
60462     } catch (...) {
60463       {
60464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60465       };
60466     }
60467   }
60468 }
60469
60470
60471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60472   unsigned int jresult ;
60473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60474   bool result;
60475
60476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60477   {
60478     try {
60479       result = (bool)(arg1)->HasKeyInputFocus();
60480     } catch (std::out_of_range& e) {
60481       {
60482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (std::exception& e) {
60485       {
60486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60487       };
60488     } catch (...) {
60489       {
60490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60491       };
60492     }
60493   }
60494   jresult = result;
60495   return jresult;
60496 }
60497
60498
60499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60501
60502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60503   {
60504     try {
60505       (arg1)->ClearKeyInputFocus();
60506     } catch (std::out_of_range& e) {
60507       {
60508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60509       };
60510     } catch (std::exception& e) {
60511       {
60512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60513       };
60514     } catch (...) {
60515       {
60516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60517       };
60518     }
60519   }
60520 }
60521
60522
60523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60525   bool arg2 ;
60526
60527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60528   arg2 = jarg2 ? true : false;
60529   {
60530     try {
60531       (arg1)->SetAsKeyboardFocusGroup(arg2);
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60539       };
60540     } catch (...) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60543       };
60544     }
60545   }
60546 }
60547
60548
60549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60550   unsigned int jresult ;
60551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60552   bool result;
60553
60554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60555   {
60556     try {
60557       result = (bool)(arg1)->IsKeyboardFocusGroup();
60558     } catch (std::out_of_range& e) {
60559       {
60560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60561       };
60562     } catch (std::exception& e) {
60563       {
60564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (...) {
60567       {
60568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60569       };
60570     }
60571   }
60572   jresult = result;
60573   return jresult;
60574 }
60575
60576
60577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60579
60580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60581   {
60582     try {
60583       (arg1)->AccessibilityActivate();
60584     } catch (std::out_of_range& e) {
60585       {
60586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60587       };
60588     } catch (std::exception& e) {
60589       {
60590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60591       };
60592     } catch (...) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60595       };
60596     }
60597   }
60598 }
60599
60600
60601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60603
60604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60605   {
60606     try {
60607       (arg1)->KeyboardEnter();
60608     } catch (std::out_of_range& e) {
60609       {
60610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60611       };
60612     } catch (std::exception& e) {
60613       {
60614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60615       };
60616     } catch (...) {
60617       {
60618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60619       };
60620     }
60621   }
60622 }
60623
60624
60625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60626   void * jresult ;
60627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60628   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60629
60630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60631   {
60632     try {
60633       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60634     } catch (std::out_of_range& e) {
60635       {
60636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60637       };
60638     } catch (std::exception& e) {
60639       {
60640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (...) {
60643       {
60644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60645       };
60646     }
60647   }
60648   jresult = (void *)result;
60649   return jresult;
60650 }
60651
60652
60653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60654   void * jresult ;
60655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60656   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60657
60658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60659   {
60660     try {
60661       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60662     } catch (std::out_of_range& e) {
60663       {
60664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60665       };
60666     } catch (std::exception& e) {
60667       {
60668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60669       };
60670     } catch (...) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60673       };
60674     }
60675   }
60676   jresult = (void *)result;
60677   return jresult;
60678 }
60679
60680
60681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60682   void * jresult ;
60683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60684   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60685
60686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60687   {
60688     try {
60689       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704   jresult = (void *)result;
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60710   unsigned int jresult ;
60711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60712   Dali::KeyEvent *arg2 = 0 ;
60713   bool result;
60714
60715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60716   arg2 = (Dali::KeyEvent *)jarg2;
60717   if (!arg2) {
60718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60719     return 0;
60720   }
60721   {
60722     try {
60723       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60724     } catch (std::out_of_range& e) {
60725       {
60726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60727       };
60728     } catch (std::exception& e) {
60729       {
60730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (...) {
60733       {
60734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60735       };
60736     }
60737   }
60738   jresult = result;
60739   return jresult;
60740 }
60741
60742
60743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60745   int arg2 ;
60746   SwigDirector_ViewImpl *darg = 0;
60747
60748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60749   arg2 = (int)jarg2;
60750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60751   {
60752     try {
60753       (darg)->OnStageConnection(arg2);
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60761       };
60762     } catch (...) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60765       };
60766     }
60767   }
60768 }
60769
60770
60771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60773   int arg2 ;
60774   SwigDirector_ViewImpl *darg = 0;
60775
60776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60777   arg2 = (int)jarg2;
60778   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60779   {
60780     try {
60781       (darg)->OnStageConnectionSwigPublic(arg2);
60782     } catch (std::out_of_range& e) {
60783       {
60784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60785       };
60786     } catch (std::exception& e) {
60787       {
60788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60789       };
60790     } catch (...) {
60791       {
60792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60793       };
60794     }
60795   }
60796 }
60797
60798
60799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60801   SwigDirector_ViewImpl *darg = 0;
60802
60803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60805   {
60806     try {
60807       (darg)->OnStageDisconnection();
60808     } catch (std::out_of_range& e) {
60809       {
60810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (std::exception& e) {
60813       {
60814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60815       };
60816     } catch (...) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60819       };
60820     }
60821   }
60822 }
60823
60824
60825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60827   SwigDirector_ViewImpl *darg = 0;
60828
60829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60830   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60831   {
60832     try {
60833       (darg)->OnStageDisconnectionSwigPublic();
60834     } catch (std::out_of_range& e) {
60835       {
60836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60837       };
60838     } catch (std::exception& e) {
60839       {
60840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60845       };
60846     }
60847   }
60848 }
60849
60850
60851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60853   Dali::Actor *arg2 = 0 ;
60854   SwigDirector_ViewImpl *darg = 0;
60855
60856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60857   arg2 = (Dali::Actor *)jarg2;
60858   if (!arg2) {
60859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60860     return ;
60861   }
60862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60863   {
60864     try {
60865       (darg)->OnChildAdd(*arg2);
60866     } catch (std::out_of_range& e) {
60867       {
60868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60869       };
60870     } catch (std::exception& e) {
60871       {
60872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60873       };
60874     } catch (...) {
60875       {
60876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60877       };
60878     }
60879   }
60880 }
60881
60882
60883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60885   Dali::Actor *arg2 = 0 ;
60886   SwigDirector_ViewImpl *darg = 0;
60887
60888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60889   arg2 = (Dali::Actor *)jarg2;
60890   if (!arg2) {
60891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60892     return ;
60893   }
60894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60895   {
60896     try {
60897       (darg)->OnChildAddSwigPublic(*arg2);
60898     } catch (std::out_of_range& e) {
60899       {
60900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60901       };
60902     } catch (std::exception& e) {
60903       {
60904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60909       };
60910     }
60911   }
60912 }
60913
60914
60915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60917   Dali::Actor *arg2 = 0 ;
60918   SwigDirector_ViewImpl *darg = 0;
60919
60920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60921   arg2 = (Dali::Actor *)jarg2;
60922   if (!arg2) {
60923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60924     return ;
60925   }
60926   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60927   {
60928     try {
60929       (darg)->OnChildRemove(*arg2);
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60941       };
60942     }
60943   }
60944 }
60945
60946
60947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60949   Dali::Actor *arg2 = 0 ;
60950   SwigDirector_ViewImpl *darg = 0;
60951
60952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60953   arg2 = (Dali::Actor *)jarg2;
60954   if (!arg2) {
60955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60956     return ;
60957   }
60958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60959   {
60960     try {
60961       (darg)->OnChildRemoveSwigPublic(*arg2);
60962     } catch (std::out_of_range& e) {
60963       {
60964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60965       };
60966     } catch (std::exception& e) {
60967       {
60968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60973       };
60974     }
60975   }
60976 }
60977
60978
60979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60981   Dali::Property::Index arg2 ;
60982   Dali::Property::Value arg3 ;
60983   Dali::Property::Value *argp3 ;
60984   SwigDirector_ViewImpl *darg = 0;
60985
60986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60987   arg2 = (Dali::Property::Index)jarg2;
60988   argp3 = (Dali::Property::Value *)jarg3;
60989   if (!argp3) {
60990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60991     return ;
60992   }
60993   arg3 = *argp3;
60994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60995   {
60996     try {
60997       (darg)->OnPropertySet(arg2,arg3);
60998     } catch (std::out_of_range& e) {
60999       {
61000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61001       };
61002     } catch (std::exception& e) {
61003       {
61004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61005       };
61006     } catch (...) {
61007       {
61008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61009       };
61010     }
61011   }
61012 }
61013
61014
61015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61017   Dali::Property::Index arg2 ;
61018   Dali::Property::Value arg3 ;
61019   Dali::Property::Value *argp3 ;
61020   SwigDirector_ViewImpl *darg = 0;
61021
61022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61023   arg2 = (Dali::Property::Index)jarg2;
61024   argp3 = (Dali::Property::Value *)jarg3;
61025   if (!argp3) {
61026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61027     return ;
61028   }
61029   arg3 = *argp3;
61030   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61031   {
61032     try {
61033       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61034     } catch (std::out_of_range& e) {
61035       {
61036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61037       };
61038     } catch (std::exception& e) {
61039       {
61040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61041       };
61042     } catch (...) {
61043       {
61044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61045       };
61046     }
61047   }
61048 }
61049
61050
61051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61053   Dali::Vector3 *arg2 = 0 ;
61054   SwigDirector_ViewImpl *darg = 0;
61055
61056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61057   arg2 = (Dali::Vector3 *)jarg2;
61058   if (!arg2) {
61059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61060     return ;
61061   }
61062   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61063   {
61064     try {
61065       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61066     } catch (std::out_of_range& e) {
61067       {
61068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61069       };
61070     } catch (std::exception& e) {
61071       {
61072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61073       };
61074     } catch (...) {
61075       {
61076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61077       };
61078     }
61079   }
61080 }
61081
61082
61083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61085   Dali::Vector3 *arg2 = 0 ;
61086   SwigDirector_ViewImpl *darg = 0;
61087
61088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61089   arg2 = (Dali::Vector3 *)jarg2;
61090   if (!arg2) {
61091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61092     return ;
61093   }
61094   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61095   {
61096     try {
61097       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61098     } catch (std::out_of_range& e) {
61099       {
61100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61101       };
61102     } catch (std::exception& e) {
61103       {
61104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61105       };
61106     } catch (...) {
61107       {
61108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61109       };
61110     }
61111   }
61112 }
61113
61114
61115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61117   Dali::Animation *arg2 = 0 ;
61118   Dali::Vector3 *arg3 = 0 ;
61119   SwigDirector_ViewImpl *darg = 0;
61120
61121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61122   arg2 = (Dali::Animation *)jarg2;
61123   if (!arg2) {
61124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61125     return ;
61126   }
61127   arg3 = (Dali::Vector3 *)jarg3;
61128   if (!arg3) {
61129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61130     return ;
61131   }
61132   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61133   {
61134     try {
61135       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61136     } catch (std::out_of_range& e) {
61137       {
61138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61139       };
61140     } catch (std::exception& e) {
61141       {
61142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61143       };
61144     } catch (...) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61147       };
61148     }
61149   }
61150 }
61151
61152
61153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61155   Dali::Animation *arg2 = 0 ;
61156   Dali::Vector3 *arg3 = 0 ;
61157   SwigDirector_ViewImpl *darg = 0;
61158
61159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61160   arg2 = (Dali::Animation *)jarg2;
61161   if (!arg2) {
61162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61163     return ;
61164   }
61165   arg3 = (Dali::Vector3 *)jarg3;
61166   if (!arg3) {
61167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61168     return ;
61169   }
61170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61171   {
61172     try {
61173       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61181       };
61182     } catch (...) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61185       };
61186     }
61187   }
61188 }
61189
61190
61191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61192   unsigned int jresult ;
61193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61194   Dali::TouchEvent *arg2 = 0 ;
61195   SwigDirector_ViewImpl *darg = 0;
61196   bool result;
61197
61198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61199   arg2 = (Dali::TouchEvent *)jarg2;
61200   if (!arg2) {
61201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61202     return 0;
61203   }
61204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61205   {
61206     try {
61207       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61208     } catch (std::out_of_range& e) {
61209       {
61210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61211       };
61212     } catch (std::exception& e) {
61213       {
61214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (...) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61219       };
61220     }
61221   }
61222   jresult = result;
61223   return jresult;
61224 }
61225
61226
61227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61228   unsigned int jresult ;
61229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61230   Dali::TouchEvent *arg2 = 0 ;
61231   SwigDirector_ViewImpl *darg = 0;
61232   bool result;
61233
61234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61235   arg2 = (Dali::TouchEvent *)jarg2;
61236   if (!arg2) {
61237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61238     return 0;
61239   }
61240   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61241   {
61242     try {
61243       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61244     } catch (std::out_of_range& e) {
61245       {
61246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61247       };
61248     } catch (std::exception& e) {
61249       {
61250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61251       };
61252     } catch (...) {
61253       {
61254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61255       };
61256     }
61257   }
61258   jresult = result;
61259   return jresult;
61260 }
61261
61262
61263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61264   unsigned int jresult ;
61265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61266   Dali::HoverEvent *arg2 = 0 ;
61267   SwigDirector_ViewImpl *darg = 0;
61268   bool result;
61269
61270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61271   arg2 = (Dali::HoverEvent *)jarg2;
61272   if (!arg2) {
61273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61274     return 0;
61275   }
61276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61277   {
61278     try {
61279       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61280     } catch (std::out_of_range& e) {
61281       {
61282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61283       };
61284     } catch (std::exception& e) {
61285       {
61286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (...) {
61289       {
61290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61291       };
61292     }
61293   }
61294   jresult = result;
61295   return jresult;
61296 }
61297
61298
61299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61300   unsigned int jresult ;
61301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61302   Dali::HoverEvent *arg2 = 0 ;
61303   SwigDirector_ViewImpl *darg = 0;
61304   bool result;
61305
61306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61307   arg2 = (Dali::HoverEvent *)jarg2;
61308   if (!arg2) {
61309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61310     return 0;
61311   }
61312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61313   {
61314     try {
61315       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61316     } catch (std::out_of_range& e) {
61317       {
61318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61319       };
61320     } catch (std::exception& e) {
61321       {
61322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61323       };
61324     } catch (...) {
61325       {
61326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61327       };
61328     }
61329   }
61330   jresult = result;
61331   return jresult;
61332 }
61333
61334
61335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61336   unsigned int jresult ;
61337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61338   Dali::KeyEvent *arg2 = 0 ;
61339   SwigDirector_ViewImpl *darg = 0;
61340   bool result;
61341
61342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61343   arg2 = (Dali::KeyEvent *)jarg2;
61344   if (!arg2) {
61345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61346     return 0;
61347   }
61348   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61349   {
61350     try {
61351       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61352     } catch (std::out_of_range& e) {
61353       {
61354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (std::exception& e) {
61357       {
61358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61363       };
61364     }
61365   }
61366   jresult = result;
61367   return jresult;
61368 }
61369
61370
61371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61372   unsigned int jresult ;
61373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61374   Dali::KeyEvent *arg2 = 0 ;
61375   SwigDirector_ViewImpl *darg = 0;
61376   bool result;
61377
61378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61379   arg2 = (Dali::KeyEvent *)jarg2;
61380   if (!arg2) {
61381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61382     return 0;
61383   }
61384   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61385   {
61386     try {
61387       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61399       };
61400     }
61401   }
61402   jresult = result;
61403   return jresult;
61404 }
61405
61406
61407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61408   unsigned int jresult ;
61409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61410   Dali::WheelEvent *arg2 = 0 ;
61411   SwigDirector_ViewImpl *darg = 0;
61412   bool result;
61413
61414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61415   arg2 = (Dali::WheelEvent *)jarg2;
61416   if (!arg2) {
61417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61418     return 0;
61419   }
61420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61421   {
61422     try {
61423       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61424     } catch (std::out_of_range& e) {
61425       {
61426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (std::exception& e) {
61429       {
61430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (...) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61435       };
61436     }
61437   }
61438   jresult = result;
61439   return jresult;
61440 }
61441
61442
61443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61444   unsigned int jresult ;
61445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61446   Dali::WheelEvent *arg2 = 0 ;
61447   SwigDirector_ViewImpl *darg = 0;
61448   bool result;
61449
61450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61451   arg2 = (Dali::WheelEvent *)jarg2;
61452   if (!arg2) {
61453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61454     return 0;
61455   }
61456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61457   {
61458     try {
61459       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61460     } catch (std::out_of_range& e) {
61461       {
61462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61463       };
61464     } catch (std::exception& e) {
61465       {
61466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (...) {
61469       {
61470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61471       };
61472     }
61473   }
61474   jresult = result;
61475   return jresult;
61476 }
61477
61478
61479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61481   Dali::Vector2 *arg2 = 0 ;
61482   Dali::RelayoutContainer *arg3 = 0 ;
61483   SwigDirector_ViewImpl *darg = 0;
61484
61485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61486   arg2 = (Dali::Vector2 *)jarg2;
61487   if (!arg2) {
61488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61489     return ;
61490   }
61491   arg3 = (Dali::RelayoutContainer *)jarg3;
61492   if (!arg3) {
61493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61494     return ;
61495   }
61496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61497   {
61498     try {
61499       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61500     } catch (std::out_of_range& e) {
61501       {
61502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61503       };
61504     } catch (std::exception& e) {
61505       {
61506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61507       };
61508     } catch (...) {
61509       {
61510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61511       };
61512     }
61513   }
61514 }
61515
61516
61517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61519   Dali::Vector2 *arg2 = 0 ;
61520   Dali::RelayoutContainer *arg3 = 0 ;
61521   SwigDirector_ViewImpl *darg = 0;
61522
61523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61524   arg2 = (Dali::Vector2 *)jarg2;
61525   if (!arg2) {
61526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61527     return ;
61528   }
61529   arg3 = (Dali::RelayoutContainer *)jarg3;
61530   if (!arg3) {
61531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61532     return ;
61533   }
61534   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61535   {
61536     try {
61537       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61538     } catch (std::out_of_range& e) {
61539       {
61540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61541       };
61542     } catch (std::exception& e) {
61543       {
61544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61545       };
61546     } catch (...) {
61547       {
61548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61549       };
61550     }
61551   }
61552 }
61553
61554
61555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61557   Dali::ResizePolicy::Type arg2 ;
61558   Dali::Dimension::Type arg3 ;
61559   SwigDirector_ViewImpl *darg = 0;
61560
61561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61562   arg2 = (Dali::ResizePolicy::Type)jarg2;
61563   arg3 = (Dali::Dimension::Type)jarg3;
61564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61565   {
61566     try {
61567       (darg)->OnSetResizePolicy(arg2,arg3);
61568     } catch (std::out_of_range& e) {
61569       {
61570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61571       };
61572     } catch (std::exception& e) {
61573       {
61574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61575       };
61576     } catch (...) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61579       };
61580     }
61581   }
61582 }
61583
61584
61585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61587   Dali::ResizePolicy::Type arg2 ;
61588   Dali::Dimension::Type arg3 ;
61589   SwigDirector_ViewImpl *darg = 0;
61590
61591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61592   arg2 = (Dali::ResizePolicy::Type)jarg2;
61593   arg3 = (Dali::Dimension::Type)jarg3;
61594   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61595   {
61596     try {
61597       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61598     } catch (std::out_of_range& e) {
61599       {
61600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61601       };
61602     } catch (std::exception& e) {
61603       {
61604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61605       };
61606     } catch (...) {
61607       {
61608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61609       };
61610     }
61611   }
61612 }
61613
61614
61615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61616   void * jresult ;
61617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61618   SwigDirector_ViewImpl *darg = 0;
61619   Dali::Vector3 result;
61620
61621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61622   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61623   {
61624     try {
61625       result = (darg)->GetNaturalSize();
61626     } catch (std::out_of_range& e) {
61627       {
61628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61629       };
61630     } catch (std::exception& e) {
61631       {
61632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61633       };
61634     } catch (...) {
61635       {
61636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61637       };
61638     }
61639   }
61640   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61641   return jresult;
61642 }
61643
61644
61645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61646   void * jresult ;
61647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61648   SwigDirector_ViewImpl *darg = 0;
61649   Dali::Vector3 result;
61650
61651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61653   {
61654     try {
61655       result = (darg)->GetNaturalSizeSwigPublic();
61656     } catch (std::out_of_range& e) {
61657       {
61658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61659       };
61660     } catch (std::exception& e) {
61661       {
61662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61663       };
61664     } catch (...) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61667       };
61668     }
61669   }
61670   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61671   return jresult;
61672 }
61673
61674
61675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61676   float jresult ;
61677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61678   Dali::Actor *arg2 = 0 ;
61679   Dali::Dimension::Type arg3 ;
61680   SwigDirector_ViewImpl *darg = 0;
61681   float result;
61682
61683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61684   arg2 = (Dali::Actor *)jarg2;
61685   if (!arg2) {
61686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61687     return 0;
61688   }
61689   arg3 = (Dali::Dimension::Type)jarg3;
61690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61691   {
61692     try {
61693       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (...) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61705       };
61706     }
61707   }
61708   jresult = result;
61709   return jresult;
61710 }
61711
61712
61713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61714   float jresult ;
61715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61716   Dali::Actor *arg2 = 0 ;
61717   Dali::Dimension::Type arg3 ;
61718   SwigDirector_ViewImpl *darg = 0;
61719   float result;
61720
61721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61722   arg2 = (Dali::Actor *)jarg2;
61723   if (!arg2) {
61724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61725     return 0;
61726   }
61727   arg3 = (Dali::Dimension::Type)jarg3;
61728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61729   {
61730     try {
61731       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61732     } catch (std::out_of_range& e) {
61733       {
61734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61735       };
61736     } catch (std::exception& e) {
61737       {
61738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61739       };
61740     } catch (...) {
61741       {
61742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61743       };
61744     }
61745   }
61746   jresult = result;
61747   return jresult;
61748 }
61749
61750
61751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61752   float jresult ;
61753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61754   float arg2 ;
61755   SwigDirector_ViewImpl *darg = 0;
61756   float result;
61757
61758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61759   arg2 = (float)jarg2;
61760   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61761   {
61762     try {
61763       result = (float)(darg)->GetHeightForWidth(arg2);
61764     } catch (std::out_of_range& e) {
61765       {
61766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61767       };
61768     } catch (std::exception& e) {
61769       {
61770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61771       };
61772     } catch (...) {
61773       {
61774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61775       };
61776     }
61777   }
61778   jresult = result;
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61784   float jresult ;
61785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61786   float arg2 ;
61787   SwigDirector_ViewImpl *darg = 0;
61788   float result;
61789
61790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61791   arg2 = (float)jarg2;
61792   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61793   {
61794     try {
61795       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61796     } catch (std::out_of_range& e) {
61797       {
61798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61799       };
61800     } catch (std::exception& e) {
61801       {
61802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (...) {
61805       {
61806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61807       };
61808     }
61809   }
61810   jresult = result;
61811   return jresult;
61812 }
61813
61814
61815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61816   float jresult ;
61817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61818   float arg2 ;
61819   SwigDirector_ViewImpl *darg = 0;
61820   float result;
61821
61822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61823   arg2 = (float)jarg2;
61824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61825   {
61826     try {
61827       result = (float)(darg)->GetWidthForHeight(arg2);
61828     } catch (std::out_of_range& e) {
61829       {
61830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61831       };
61832     } catch (std::exception& e) {
61833       {
61834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61835       };
61836     } catch (...) {
61837       {
61838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61839       };
61840     }
61841   }
61842   jresult = result;
61843   return jresult;
61844 }
61845
61846
61847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61848   float jresult ;
61849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61850   float arg2 ;
61851   SwigDirector_ViewImpl *darg = 0;
61852   float result;
61853
61854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61855   arg2 = (float)jarg2;
61856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61857   {
61858     try {
61859       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61860     } catch (std::out_of_range& e) {
61861       {
61862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61863       };
61864     } catch (std::exception& e) {
61865       {
61866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61867       };
61868     } catch (...) {
61869       {
61870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61871       };
61872     }
61873   }
61874   jresult = result;
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61880   unsigned int jresult ;
61881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61882   Dali::Dimension::Type arg2 ;
61883   SwigDirector_ViewImpl *darg = 0;
61884   bool result;
61885
61886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61887   arg2 = (Dali::Dimension::Type)jarg2;
61888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61889   {
61890     try {
61891       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61892     } catch (std::out_of_range& e) {
61893       {
61894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61895       };
61896     } catch (std::exception& e) {
61897       {
61898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61899       };
61900     } catch (...) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61903       };
61904     }
61905   }
61906   jresult = result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61912   unsigned int jresult ;
61913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61914   Dali::Dimension::Type arg2 ;
61915   SwigDirector_ViewImpl *darg = 0;
61916   bool result;
61917
61918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61919   arg2 = (Dali::Dimension::Type)jarg2;
61920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61921   {
61922     try {
61923       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61924     } catch (std::out_of_range& e) {
61925       {
61926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61927       };
61928     } catch (std::exception& e) {
61929       {
61930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61931       };
61932     } catch (...) {
61933       {
61934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61935       };
61936     }
61937   }
61938   jresult = result;
61939   return jresult;
61940 }
61941
61942
61943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61944   unsigned int jresult ;
61945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61946   SwigDirector_ViewImpl *darg = 0;
61947   bool result;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61951   {
61952     try {
61953       result = (bool)(darg)->RelayoutDependentOnChildren();
61954     } catch (std::out_of_range& e) {
61955       {
61956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61957       };
61958     } catch (std::exception& e) {
61959       {
61960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61961       };
61962     } catch (...) {
61963       {
61964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61965       };
61966     }
61967   }
61968   jresult = result;
61969   return jresult;
61970 }
61971
61972
61973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61974   unsigned int jresult ;
61975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61976   SwigDirector_ViewImpl *darg = 0;
61977   bool result;
61978
61979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61981   {
61982     try {
61983       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61984     } catch (std::out_of_range& e) {
61985       {
61986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61987       };
61988     } catch (std::exception& e) {
61989       {
61990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (...) {
61993       {
61994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61995       };
61996     }
61997   }
61998   jresult = result;
61999   return jresult;
62000 }
62001
62002
62003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62004   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62005   Dali::Dimension::Type arg2 ;
62006   SwigDirector_ViewImpl *darg = 0;
62007
62008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62009   arg2 = (Dali::Dimension::Type)jarg2;
62010   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62011   {
62012     try {
62013       (darg)->OnCalculateRelayoutSize(arg2);
62014     } catch (std::out_of_range& e) {
62015       {
62016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62017       };
62018     } catch (std::exception& e) {
62019       {
62020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62021       };
62022     } catch (...) {
62023       {
62024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62025       };
62026     }
62027   }
62028 }
62029
62030
62031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62033   Dali::Dimension::Type arg2 ;
62034   SwigDirector_ViewImpl *darg = 0;
62035
62036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62037   arg2 = (Dali::Dimension::Type)jarg2;
62038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62039   {
62040     try {
62041       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62042     } catch (std::out_of_range& e) {
62043       {
62044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62045       };
62046     } catch (std::exception& e) {
62047       {
62048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62049       };
62050     } catch (...) {
62051       {
62052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62053       };
62054     }
62055   }
62056 }
62057
62058
62059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62061   float arg2 ;
62062   Dali::Dimension::Type arg3 ;
62063   SwigDirector_ViewImpl *darg = 0;
62064
62065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62066   arg2 = (float)jarg2;
62067   arg3 = (Dali::Dimension::Type)jarg3;
62068   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62069   {
62070     try {
62071       (darg)->OnLayoutNegotiated(arg2,arg3);
62072     } catch (std::out_of_range& e) {
62073       {
62074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62075       };
62076     } catch (std::exception& e) {
62077       {
62078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62079       };
62080     } catch (...) {
62081       {
62082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62083       };
62084     }
62085   }
62086 }
62087
62088
62089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62091   float arg2 ;
62092   Dali::Dimension::Type arg3 ;
62093   SwigDirector_ViewImpl *darg = 0;
62094
62095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62096   arg2 = (float)jarg2;
62097   arg3 = (Dali::Dimension::Type)jarg3;
62098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62099   {
62100     try {
62101       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62102     } catch (std::out_of_range& e) {
62103       {
62104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62105       };
62106     } catch (std::exception& e) {
62107       {
62108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (...) {
62111       {
62112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62113       };
62114     }
62115   }
62116 }
62117
62118
62119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62121
62122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62123   {
62124     try {
62125       (arg1)->OnInitialize();
62126     } catch (std::out_of_range& e) {
62127       {
62128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62129       };
62130     } catch (std::exception& e) {
62131       {
62132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62133       };
62134     } catch (...) {
62135       {
62136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62137       };
62138     }
62139   }
62140 }
62141
62142
62143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62145
62146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62147   {
62148     try {
62149       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62150     } catch (std::out_of_range& e) {
62151       {
62152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62153       };
62154     } catch (std::exception& e) {
62155       {
62156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62157       };
62158     } catch (...) {
62159       {
62160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62161       };
62162     }
62163   }
62164 }
62165
62166
62167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62169   Dali::Actor *arg2 = 0 ;
62170
62171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62172   arg2 = (Dali::Actor *)jarg2;
62173   if (!arg2) {
62174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62175     return ;
62176   }
62177   {
62178     try {
62179       (arg1)->OnControlChildAdd(*arg2);
62180     } catch (std::out_of_range& e) {
62181       {
62182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62183       };
62184     } catch (std::exception& e) {
62185       {
62186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62187       };
62188     } catch (...) {
62189       {
62190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62191       };
62192     }
62193   }
62194 }
62195
62196
62197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62199   Dali::Actor *arg2 = 0 ;
62200
62201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62202   arg2 = (Dali::Actor *)jarg2;
62203   if (!arg2) {
62204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62205     return ;
62206   }
62207   {
62208     try {
62209       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62210     } catch (std::out_of_range& e) {
62211       {
62212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62213       };
62214     } catch (std::exception& e) {
62215       {
62216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62217       };
62218     } catch (...) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62221       };
62222     }
62223   }
62224 }
62225
62226
62227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62229   Dali::Actor *arg2 = 0 ;
62230
62231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62232   arg2 = (Dali::Actor *)jarg2;
62233   if (!arg2) {
62234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62235     return ;
62236   }
62237   {
62238     try {
62239       (arg1)->OnControlChildRemove(*arg2);
62240     } catch (std::out_of_range& e) {
62241       {
62242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (std::exception& e) {
62245       {
62246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (...) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62251       };
62252     }
62253   }
62254 }
62255
62256
62257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62259   Dali::Actor *arg2 = 0 ;
62260
62261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62262   arg2 = (Dali::Actor *)jarg2;
62263   if (!arg2) {
62264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62265     return ;
62266   }
62267   {
62268     try {
62269       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62281       };
62282     }
62283   }
62284 }
62285
62286
62287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62289   Dali::Toolkit::StyleManager arg2 ;
62290   Dali::StyleChange::Type arg3 ;
62291   Dali::Toolkit::StyleManager *argp2 ;
62292
62293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62294   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62295   if (!argp2) {
62296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62297     return ;
62298   }
62299   arg2 = *argp2;
62300   arg3 = (Dali::StyleChange::Type)jarg3;
62301   {
62302     try {
62303       (arg1)->OnStyleChange(arg2,arg3);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62315       };
62316     }
62317   }
62318 }
62319
62320
62321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62323   Dali::Toolkit::StyleManager arg2 ;
62324   Dali::StyleChange::Type arg3 ;
62325   Dali::Toolkit::StyleManager *argp2 ;
62326
62327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62328   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62329   if (!argp2) {
62330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62331     return ;
62332   }
62333   arg2 = *argp2;
62334   arg3 = (Dali::StyleChange::Type)jarg3;
62335   {
62336     try {
62337       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62338     } catch (std::out_of_range& e) {
62339       {
62340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (std::exception& e) {
62343       {
62344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62345       };
62346     } catch (...) {
62347       {
62348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62349       };
62350     }
62351   }
62352 }
62353
62354
62355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62356   unsigned int jresult ;
62357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62358   bool result;
62359
62360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62361   {
62362     try {
62363       result = (bool)(arg1)->OnAccessibilityActivated();
62364     } catch (std::out_of_range& e) {
62365       {
62366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62367       };
62368     } catch (std::exception& e) {
62369       {
62370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62371       };
62372     } catch (...) {
62373       {
62374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62375       };
62376     }
62377   }
62378   jresult = result;
62379   return jresult;
62380 }
62381
62382
62383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62384   unsigned int jresult ;
62385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62386   bool result;
62387
62388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62389   {
62390     try {
62391       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406   jresult = result;
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62412   unsigned int jresult ;
62413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62414   Dali::PanGesture arg2 ;
62415   Dali::PanGesture *argp2 ;
62416   bool result;
62417
62418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62419   argp2 = (Dali::PanGesture *)jarg2;
62420   if (!argp2) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62422     return 0;
62423   }
62424   arg2 = *argp2;
62425   {
62426     try {
62427       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62428     } catch (std::out_of_range& e) {
62429       {
62430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62431       };
62432     } catch (std::exception& e) {
62433       {
62434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62435       };
62436     } catch (...) {
62437       {
62438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62439       };
62440     }
62441   }
62442   jresult = result;
62443   return jresult;
62444 }
62445
62446
62447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62448   unsigned int jresult ;
62449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62450   Dali::PanGesture arg2 ;
62451   Dali::PanGesture *argp2 ;
62452   bool result;
62453
62454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62455   argp2 = (Dali::PanGesture *)jarg2;
62456   if (!argp2) {
62457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62458     return 0;
62459   }
62460   arg2 = *argp2;
62461   {
62462     try {
62463       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62464     } catch (std::out_of_range& e) {
62465       {
62466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62467       };
62468     } catch (std::exception& e) {
62469       {
62470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62471       };
62472     } catch (...) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62475       };
62476     }
62477   }
62478   jresult = result;
62479   return jresult;
62480 }
62481
62482
62483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62484   unsigned int jresult ;
62485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62486   Dali::TouchEvent *arg2 = 0 ;
62487   bool result;
62488
62489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62490   arg2 = (Dali::TouchEvent *)jarg2;
62491   if (!arg2) {
62492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62493     return 0;
62494   }
62495   {
62496     try {
62497       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62498     } catch (std::out_of_range& e) {
62499       {
62500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62501       };
62502     } catch (std::exception& e) {
62503       {
62504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (...) {
62507       {
62508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62509       };
62510     }
62511   }
62512   jresult = result;
62513   return jresult;
62514 }
62515
62516
62517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62518   unsigned int jresult ;
62519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62520   Dali::TouchEvent *arg2 = 0 ;
62521   bool result;
62522
62523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62524   arg2 = (Dali::TouchEvent *)jarg2;
62525   if (!arg2) {
62526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62527     return 0;
62528   }
62529   {
62530     try {
62531       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (...) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62543       };
62544     }
62545   }
62546   jresult = result;
62547   return jresult;
62548 }
62549
62550
62551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62552   unsigned int jresult ;
62553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62554   bool arg2 ;
62555   bool result;
62556
62557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62558   arg2 = jarg2 ? true : false;
62559   {
62560     try {
62561       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62562     } catch (std::out_of_range& e) {
62563       {
62564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62565       };
62566     } catch (std::exception& e) {
62567       {
62568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (...) {
62571       {
62572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62573       };
62574     }
62575   }
62576   jresult = result;
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62582   unsigned int jresult ;
62583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62584   bool arg2 ;
62585   bool result;
62586
62587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62588   arg2 = jarg2 ? true : false;
62589   {
62590     try {
62591       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62592     } catch (std::out_of_range& e) {
62593       {
62594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62595       };
62596     } catch (std::exception& e) {
62597       {
62598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62603       };
62604     }
62605   }
62606   jresult = result;
62607   return jresult;
62608 }
62609
62610
62611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62612   unsigned int jresult ;
62613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62614   bool result;
62615
62616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62617   {
62618     try {
62619       result = (bool)(arg1)->OnAccessibilityZoom();
62620     } catch (std::out_of_range& e) {
62621       {
62622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62623       };
62624     } catch (std::exception& e) {
62625       {
62626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62627       };
62628     } catch (...) {
62629       {
62630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62631       };
62632     }
62633   }
62634   jresult = result;
62635   return jresult;
62636 }
62637
62638
62639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62640   unsigned int jresult ;
62641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62642   bool result;
62643
62644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62645   {
62646     try {
62647       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62648     } catch (std::out_of_range& e) {
62649       {
62650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62651       };
62652     } catch (std::exception& e) {
62653       {
62654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62655       };
62656     } catch (...) {
62657       {
62658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62659       };
62660     }
62661   }
62662   jresult = result;
62663   return jresult;
62664 }
62665
62666
62667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62669
62670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62671   {
62672     try {
62673       (arg1)->OnKeyInputFocusGained();
62674     } catch (std::out_of_range& e) {
62675       {
62676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62677       };
62678     } catch (std::exception& e) {
62679       {
62680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62681       };
62682     } catch (...) {
62683       {
62684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62685       };
62686     }
62687   }
62688 }
62689
62690
62691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62693
62694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62695   {
62696     try {
62697       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62698     } catch (std::out_of_range& e) {
62699       {
62700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62701       };
62702     } catch (std::exception& e) {
62703       {
62704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62705       };
62706     } catch (...) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62709       };
62710     }
62711   }
62712 }
62713
62714
62715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62717
62718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62719   {
62720     try {
62721       (arg1)->OnKeyInputFocusLost();
62722     } catch (std::out_of_range& e) {
62723       {
62724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62725       };
62726     } catch (std::exception& e) {
62727       {
62728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62733       };
62734     }
62735   }
62736 }
62737
62738
62739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62741
62742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62743   {
62744     try {
62745       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62746     } catch (std::out_of_range& e) {
62747       {
62748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62749       };
62750     } catch (std::exception& e) {
62751       {
62752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62753       };
62754     } catch (...) {
62755       {
62756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62757       };
62758     }
62759   }
62760 }
62761
62762
62763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62764   void * jresult ;
62765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62766   Dali::Actor arg2 ;
62767   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62768   bool arg4 ;
62769   Dali::Actor *argp2 ;
62770   Dali::Actor result;
62771
62772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62773   argp2 = (Dali::Actor *)jarg2;
62774   if (!argp2) {
62775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62776     return 0;
62777   }
62778   arg2 = *argp2;
62779   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62780   arg4 = jarg4 ? true : false;
62781   {
62782     try {
62783       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62795       };
62796     }
62797   }
62798   jresult = new Dali::Actor((const Dali::Actor &)result);
62799   return jresult;
62800 }
62801
62802
62803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62804   void * jresult ;
62805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62806   Dali::Actor arg2 ;
62807   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62808   bool arg4 ;
62809   Dali::Actor *argp2 ;
62810   Dali::Actor result;
62811
62812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62813   argp2 = (Dali::Actor *)jarg2;
62814   if (!argp2) {
62815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62816     return 0;
62817   }
62818   arg2 = *argp2;
62819   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62820   arg4 = jarg4 ? true : false;
62821   {
62822     try {
62823       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62824     } catch (std::out_of_range& e) {
62825       {
62826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (std::exception& e) {
62829       {
62830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62831       };
62832     } catch (...) {
62833       {
62834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62835       };
62836     }
62837   }
62838   jresult = new Dali::Actor((const Dali::Actor &)result);
62839   return jresult;
62840 }
62841
62842
62843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62845   Dali::Actor arg2 ;
62846   Dali::Actor *argp2 ;
62847
62848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62849   argp2 = (Dali::Actor *)jarg2;
62850   if (!argp2) {
62851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62852     return ;
62853   }
62854   arg2 = *argp2;
62855   {
62856     try {
62857       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62858     } catch (std::out_of_range& e) {
62859       {
62860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62861       };
62862     } catch (std::exception& e) {
62863       {
62864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62865       };
62866     } catch (...) {
62867       {
62868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62869       };
62870     }
62871   }
62872 }
62873
62874
62875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62877   Dali::Actor arg2 ;
62878   Dali::Actor *argp2 ;
62879
62880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62881   argp2 = (Dali::Actor *)jarg2;
62882   if (!argp2) {
62883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62884     return ;
62885   }
62886   arg2 = *argp2;
62887   {
62888     try {
62889       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62890     } catch (std::out_of_range& e) {
62891       {
62892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62893       };
62894     } catch (std::exception& e) {
62895       {
62896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62897       };
62898     } catch (...) {
62899       {
62900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62901       };
62902     }
62903   }
62904 }
62905
62906
62907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62908   unsigned int jresult ;
62909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62910   bool result;
62911
62912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62913   {
62914     try {
62915       result = (bool)(arg1)->OnKeyboardEnter();
62916     } catch (std::out_of_range& e) {
62917       {
62918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62919       };
62920     } catch (std::exception& e) {
62921       {
62922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62923       };
62924     } catch (...) {
62925       {
62926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62927       };
62928     }
62929   }
62930   jresult = result;
62931   return jresult;
62932 }
62933
62934
62935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62936   unsigned int jresult ;
62937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62938   bool result;
62939
62940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62941   {
62942     try {
62943       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62944     } catch (std::out_of_range& e) {
62945       {
62946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62947       };
62948     } catch (std::exception& e) {
62949       {
62950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62951       };
62952     } catch (...) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62955       };
62956     }
62957   }
62958   jresult = result;
62959   return jresult;
62960 }
62961
62962
62963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62965   Dali::PinchGesture *arg2 = 0 ;
62966
62967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62968   arg2 = (Dali::PinchGesture *)jarg2;
62969   if (!arg2) {
62970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62971     return ;
62972   }
62973   {
62974     try {
62975       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62976     } catch (std::out_of_range& e) {
62977       {
62978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62979       };
62980     } catch (std::exception& e) {
62981       {
62982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62983       };
62984     } catch (...) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62987       };
62988     }
62989   }
62990 }
62991
62992
62993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62994   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62995   Dali::PinchGesture *arg2 = 0 ;
62996
62997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62998   arg2 = (Dali::PinchGesture *)jarg2;
62999   if (!arg2) {
63000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63001     return ;
63002   }
63003   {
63004     try {
63005       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63006     } catch (std::out_of_range& e) {
63007       {
63008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63009       };
63010     } catch (std::exception& e) {
63011       {
63012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63017       };
63018     }
63019   }
63020 }
63021
63022
63023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63025   Dali::PanGesture *arg2 = 0 ;
63026
63027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63028   arg2 = (Dali::PanGesture *)jarg2;
63029   if (!arg2) {
63030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63031     return ;
63032   }
63033   {
63034     try {
63035       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63036     } catch (std::out_of_range& e) {
63037       {
63038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63039       };
63040     } catch (std::exception& e) {
63041       {
63042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63047       };
63048     }
63049   }
63050 }
63051
63052
63053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63055   Dali::PanGesture *arg2 = 0 ;
63056
63057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63058   arg2 = (Dali::PanGesture *)jarg2;
63059   if (!arg2) {
63060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63061     return ;
63062   }
63063   {
63064     try {
63065       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63066     } catch (std::out_of_range& e) {
63067       {
63068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63069       };
63070     } catch (std::exception& e) {
63071       {
63072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63077       };
63078     }
63079   }
63080 }
63081
63082
63083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63085   Dali::TapGesture *arg2 = 0 ;
63086
63087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63088   arg2 = (Dali::TapGesture *)jarg2;
63089   if (!arg2) {
63090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63091     return ;
63092   }
63093   {
63094     try {
63095       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63096     } catch (std::out_of_range& e) {
63097       {
63098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63099       };
63100     } catch (std::exception& e) {
63101       {
63102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63103       };
63104     } catch (...) {
63105       {
63106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63107       };
63108     }
63109   }
63110 }
63111
63112
63113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63115   Dali::TapGesture *arg2 = 0 ;
63116
63117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63118   arg2 = (Dali::TapGesture *)jarg2;
63119   if (!arg2) {
63120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63121     return ;
63122   }
63123   {
63124     try {
63125       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63126     } catch (std::out_of_range& e) {
63127       {
63128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63129       };
63130     } catch (std::exception& e) {
63131       {
63132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63133       };
63134     } catch (...) {
63135       {
63136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63137       };
63138     }
63139   }
63140 }
63141
63142
63143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63145   Dali::LongPressGesture *arg2 = 0 ;
63146
63147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63148   arg2 = (Dali::LongPressGesture *)jarg2;
63149   if (!arg2) {
63150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63151     return ;
63152   }
63153   {
63154     try {
63155       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63163       };
63164     } catch (...) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63167       };
63168     }
63169   }
63170 }
63171
63172
63173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63175   Dali::LongPressGesture *arg2 = 0 ;
63176
63177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63178   arg2 = (Dali::LongPressGesture *)jarg2;
63179   if (!arg2) {
63180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63181     return ;
63182   }
63183   {
63184     try {
63185       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63193       };
63194     } catch (...) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63197       };
63198     }
63199   }
63200 }
63201
63202
63203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63205   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63206   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63207
63208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63209   arg2 = (Dali::SlotObserver *)jarg2;
63210   arg3 = (Dali::CallbackBase *)jarg3;
63211   {
63212     try {
63213       (arg1)->SignalConnected(arg2,arg3);
63214     } catch (std::out_of_range& e) {
63215       {
63216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (std::exception& e) {
63219       {
63220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63221       };
63222     } catch (...) {
63223       {
63224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63225       };
63226     }
63227   }
63228 }
63229
63230
63231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63233   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63234   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63235
63236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63237   arg2 = (Dali::SlotObserver *)jarg2;
63238   arg3 = (Dali::CallbackBase *)jarg3;
63239   {
63240     try {
63241       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63242     } catch (std::out_of_range& e) {
63243       {
63244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (std::exception& e) {
63247       {
63248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63253       };
63254     }
63255   }
63256 }
63257
63258
63259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63261   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63262   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63263
63264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63265   arg2 = (Dali::SlotObserver *)jarg2;
63266   arg3 = (Dali::CallbackBase *)jarg3;
63267   {
63268     try {
63269       (arg1)->SignalDisconnected(arg2,arg3);
63270     } catch (std::out_of_range& e) {
63271       {
63272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63273       };
63274     } catch (std::exception& e) {
63275       {
63276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63277       };
63278     } catch (...) {
63279       {
63280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63281       };
63282     }
63283   }
63284 }
63285
63286
63287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63289   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63290   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63291
63292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63293   arg2 = (Dali::SlotObserver *)jarg2;
63294   arg3 = (Dali::CallbackBase *)jarg3;
63295   {
63296     try {
63297       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63298     } catch (std::out_of_range& e) {
63299       {
63300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63301       };
63302     } catch (std::exception& e) {
63303       {
63304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63305       };
63306     } catch (...) {
63307       {
63308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63309       };
63310     }
63311   }
63312 }
63313
63314
63315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback7_t callback7, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback22_t callback22, SwigDirector_ViewImpl::SWIG_Callback23_t callback23, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
63316   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63317   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63318   if (director) {
63319     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
63320   }
63321 }
63322
63323
63324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63325   void * jresult ;
63326   Dali::Toolkit::Control *arg1 = 0 ;
63327   Dali::Toolkit::Internal::Control *result = 0 ;
63328
63329   arg1 = (Dali::Toolkit::Control *)jarg1;
63330   if (!arg1) {
63331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63332     return 0;
63333   }
63334   {
63335     try {
63336       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63337     } catch (std::out_of_range& e) {
63338       {
63339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63340       };
63341     } catch (std::exception& e) {
63342       {
63343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (...) {
63346       {
63347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63348       };
63349     }
63350   }
63351   jresult = (void *)result;
63352   return jresult;
63353 }
63354
63355
63356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63357   int jresult ;
63358   int result;
63359
63360   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63361   jresult = (int)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63367   int jresult ;
63368   int result;
63369
63370   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63371   jresult = (int)result;
63372   return jresult;
63373 }
63374
63375
63376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63377   int jresult ;
63378   int result;
63379
63380   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63381   jresult = (int)result;
63382   return jresult;
63383 }
63384
63385
63386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63387   int jresult ;
63388   int result;
63389
63390   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63397   int jresult ;
63398   int result;
63399
63400   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63401   jresult = (int)result;
63402   return jresult;
63403 }
63404
63405
63406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63407   void * jresult ;
63408   Dali::Toolkit::Control::Property *result = 0 ;
63409
63410   {
63411     try {
63412       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63413     } catch (std::out_of_range& e) {
63414       {
63415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63416       };
63417     } catch (std::exception& e) {
63418       {
63419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63420       };
63421     } catch (...) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63424       };
63425     }
63426   }
63427   jresult = (void *)result;
63428   return jresult;
63429 }
63430
63431
63432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63433   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63434
63435   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63436   {
63437     try {
63438       delete arg1;
63439     } catch (std::out_of_range& e) {
63440       {
63441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63442       };
63443     } catch (std::exception& e) {
63444       {
63445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63450       };
63451     }
63452   }
63453 }
63454
63455
63456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63457   void * jresult ;
63458   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63459
63460   {
63461     try {
63462       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63463     } catch (std::out_of_range& e) {
63464       {
63465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63466       };
63467     } catch (std::exception& e) {
63468       {
63469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63470       };
63471     } catch (...) {
63472       {
63473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63474       };
63475     }
63476   }
63477   jresult = (void *)result;
63478   return jresult;
63479 }
63480
63481
63482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63483   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63484
63485   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63486   {
63487     try {
63488       delete arg1;
63489     } catch (std::out_of_range& e) {
63490       {
63491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63492       };
63493     } catch (std::exception& e) {
63494       {
63495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63496       };
63497     } catch (...) {
63498       {
63499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63500       };
63501     }
63502   }
63503 }
63504
63505
63506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63507   void * jresult ;
63508   Dali::Toolkit::Control result;
63509
63510   {
63511     try {
63512       result = Dali::Toolkit::Control::New();
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63520       };
63521     } catch (...) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63524       };
63525     }
63526   }
63527   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63528   return jresult;
63529 }
63530
63531
63532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63533   void * jresult ;
63534   Dali::Toolkit::Control *result = 0 ;
63535
63536   {
63537     try {
63538       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (...) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63550       };
63551     }
63552   }
63553   jresult = (void *)result;
63554   return jresult;
63555 }
63556
63557
63558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63559   void * jresult ;
63560   Dali::Toolkit::Control *arg1 = 0 ;
63561   Dali::Toolkit::Control *result = 0 ;
63562
63563   arg1 = (Dali::Toolkit::Control *)jarg1;
63564   if (!arg1) {
63565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63566     return 0;
63567   }
63568   {
63569     try {
63570       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585   jresult = (void *)result;
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63592
63593   arg1 = (Dali::Toolkit::Control *)jarg1;
63594   {
63595     try {
63596       delete arg1;
63597     } catch (std::out_of_range& e) {
63598       {
63599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63600       };
63601     } catch (std::exception& e) {
63602       {
63603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63604       };
63605     } catch (...) {
63606       {
63607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63608       };
63609     }
63610   }
63611 }
63612
63613
63614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63615   void * jresult ;
63616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63617   Dali::Toolkit::Control *arg2 = 0 ;
63618   Dali::Toolkit::Control *result = 0 ;
63619
63620   arg1 = (Dali::Toolkit::Control *)jarg1;
63621   arg2 = (Dali::Toolkit::Control *)jarg2;
63622   if (!arg2) {
63623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63624     return 0;
63625   }
63626   {
63627     try {
63628       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63629     } catch (std::out_of_range& e) {
63630       {
63631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63632       };
63633     } catch (std::exception& e) {
63634       {
63635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63640       };
63641     }
63642   }
63643   jresult = (void *)result;
63644   return jresult;
63645 }
63646
63647
63648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63649   void * jresult ;
63650   Dali::BaseHandle arg1 ;
63651   Dali::BaseHandle *argp1 ;
63652   Dali::Toolkit::Control result;
63653
63654   argp1 = (Dali::BaseHandle *)jarg1;
63655   if (!argp1) {
63656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63657     return 0;
63658   }
63659   arg1 = *argp1;
63660   {
63661     try {
63662       result = Dali::Toolkit::Control::DownCast(arg1);
63663     } catch (std::out_of_range& e) {
63664       {
63665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63666       };
63667     } catch (std::exception& e) {
63668       {
63669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (...) {
63672       {
63673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63674       };
63675     }
63676   }
63677   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63678   return jresult;
63679 }
63680
63681
63682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63683   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63684
63685   arg1 = (Dali::Toolkit::Control *)jarg1;
63686   {
63687     try {
63688       (arg1)->SetKeyInputFocus();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63696       };
63697     } catch (...) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63700       };
63701     }
63702   }
63703 }
63704
63705
63706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63707   unsigned int jresult ;
63708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63709   bool result;
63710
63711   arg1 = (Dali::Toolkit::Control *)jarg1;
63712   {
63713     try {
63714       result = (bool)(arg1)->HasKeyInputFocus();
63715     } catch (std::out_of_range& e) {
63716       {
63717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63718       };
63719     } catch (std::exception& e) {
63720       {
63721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63722       };
63723     } catch (...) {
63724       {
63725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63726       };
63727     }
63728   }
63729   jresult = result;
63730   return jresult;
63731 }
63732
63733
63734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63735   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63736
63737   arg1 = (Dali::Toolkit::Control *)jarg1;
63738   {
63739     try {
63740       (arg1)->ClearKeyInputFocus();
63741     } catch (std::out_of_range& e) {
63742       {
63743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63744       };
63745     } catch (std::exception& e) {
63746       {
63747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63752       };
63753     }
63754   }
63755 }
63756
63757
63758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63759   void * jresult ;
63760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63761   Dali::PinchGestureDetector result;
63762
63763   arg1 = (Dali::Toolkit::Control *)jarg1;
63764   {
63765     try {
63766       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63767     } catch (std::out_of_range& e) {
63768       {
63769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (std::exception& e) {
63772       {
63773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63787   void * jresult ;
63788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63789   Dali::PanGestureDetector result;
63790
63791   arg1 = (Dali::Toolkit::Control *)jarg1;
63792   {
63793     try {
63794       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63795     } catch (std::out_of_range& e) {
63796       {
63797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63798       };
63799     } catch (std::exception& e) {
63800       {
63801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63802       };
63803     } catch (...) {
63804       {
63805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63806       };
63807     }
63808   }
63809   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63810   return jresult;
63811 }
63812
63813
63814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63815   void * jresult ;
63816   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63817   Dali::TapGestureDetector result;
63818
63819   arg1 = (Dali::Toolkit::Control *)jarg1;
63820   {
63821     try {
63822       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63823     } catch (std::out_of_range& e) {
63824       {
63825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63826       };
63827     } catch (std::exception& e) {
63828       {
63829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63830       };
63831     } catch (...) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63834       };
63835     }
63836   }
63837   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63838   return jresult;
63839 }
63840
63841
63842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63843   void * jresult ;
63844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63845   Dali::LongPressGestureDetector result;
63846
63847   arg1 = (Dali::Toolkit::Control *)jarg1;
63848   {
63849     try {
63850       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63851     } catch (std::out_of_range& e) {
63852       {
63853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63854       };
63855     } catch (std::exception& e) {
63856       {
63857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63862       };
63863     }
63864   }
63865   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63866   return jresult;
63867 }
63868
63869
63870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63871   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63872   std::string *arg2 = 0 ;
63873
63874   arg1 = (Dali::Toolkit::Control *)jarg1;
63875   if (!jarg2) {
63876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63877     return ;
63878   }
63879   std::string arg2_str(jarg2);
63880   arg2 = &arg2_str;
63881   {
63882     try {
63883       (arg1)->SetStyleName((std::string const &)*arg2);
63884     } catch (std::out_of_range& e) {
63885       {
63886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (std::exception& e) {
63889       {
63890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63895       };
63896     }
63897   }
63898
63899   //argout typemap for const std::string&
63900
63901 }
63902
63903
63904 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63905   char * jresult ;
63906   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63907   std::string *result = 0 ;
63908
63909   arg1 = (Dali::Toolkit::Control *)jarg1;
63910   {
63911     try {
63912       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (...) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63924       };
63925     }
63926   }
63927   jresult = SWIG_csharp_string_callback(result->c_str());
63928   return jresult;
63929 }
63930
63931
63932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63933   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63934   Dali::Vector4 *arg2 = 0 ;
63935
63936   arg1 = (Dali::Toolkit::Control *)jarg1;
63937   arg2 = (Dali::Vector4 *)jarg2;
63938   if (!arg2) {
63939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63940     return ;
63941   }
63942   {
63943     try {
63944       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (...) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63956       };
63957     }
63958   }
63959 }
63960
63961
63962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63963   void * jresult ;
63964   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63965   Dali::Vector4 result;
63966
63967   arg1 = (Dali::Toolkit::Control *)jarg1;
63968   {
63969     try {
63970       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63971     } catch (std::out_of_range& e) {
63972       {
63973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63974       };
63975     } catch (std::exception& e) {
63976       {
63977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63978       };
63979     } catch (...) {
63980       {
63981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63982       };
63983     }
63984   }
63985   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63986   return jresult;
63987 }
63988
63989
63990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63991   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63992   Dali::Image arg2 ;
63993   Dali::Image *argp2 ;
63994
63995   arg1 = (Dali::Toolkit::Control *)jarg1;
63996   argp2 = (Dali::Image *)jarg2;
63997   if (!argp2) {
63998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63999     return ;
64000   }
64001   arg2 = *argp2;
64002   {
64003     try {
64004       (arg1)->SetBackgroundImage(arg2);
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64016       };
64017     }
64018   }
64019 }
64020
64021
64022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64023   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64024
64025   arg1 = (Dali::Toolkit::Control *)jarg1;
64026   {
64027     try {
64028       (arg1)->ClearBackground();
64029     } catch (std::out_of_range& e) {
64030       {
64031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64032       };
64033     } catch (std::exception& e) {
64034       {
64035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64036       };
64037     } catch (...) {
64038       {
64039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64040       };
64041     }
64042   }
64043 }
64044
64045
64046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64047   void * jresult ;
64048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64049   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64050
64051   arg1 = (Dali::Toolkit::Control *)jarg1;
64052   {
64053     try {
64054       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64055     } catch (std::out_of_range& e) {
64056       {
64057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64058       };
64059     } catch (std::exception& e) {
64060       {
64061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (...) {
64064       {
64065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64066       };
64067     }
64068   }
64069   jresult = (void *)result;
64070   return jresult;
64071 }
64072
64073
64074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64075   void * jresult ;
64076   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64077   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64078
64079   arg1 = (Dali::Toolkit::Control *)jarg1;
64080   {
64081     try {
64082       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64083     } catch (std::out_of_range& e) {
64084       {
64085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64086       };
64087     } catch (std::exception& e) {
64088       {
64089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64090       };
64091     } catch (...) {
64092       {
64093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64094       };
64095     }
64096   }
64097   jresult = (void *)result;
64098   return jresult;
64099 }
64100
64101
64102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64103   void * jresult ;
64104   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64105   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64106
64107   arg1 = (Dali::Toolkit::Control *)jarg1;
64108   {
64109     try {
64110       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64111     } catch (std::out_of_range& e) {
64112       {
64113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64114       };
64115     } catch (std::exception& e) {
64116       {
64117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64118       };
64119     } catch (...) {
64120       {
64121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64122       };
64123     }
64124   }
64125   jresult = (void *)result;
64126   return jresult;
64127 }
64128
64129
64130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64131   void * jresult ;
64132   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64133   Dali::Toolkit::Control *result = 0 ;
64134
64135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64136   if (!arg1) {
64137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64138     return 0;
64139   }
64140   {
64141     try {
64142       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64143     } catch (std::out_of_range& e) {
64144       {
64145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64146       };
64147     } catch (std::exception& e) {
64148       {
64149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64150       };
64151     } catch (...) {
64152       {
64153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64154       };
64155     }
64156   }
64157   jresult = (void *)result;
64158   return jresult;
64159 }
64160
64161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64162 {
64163   void * jresult;
64164   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64165   arg1 = (Dali::Toolkit::Control *)jarg1;
64166
64167   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64168
64169   Dali::Toolkit::TransitionData *arg2 = 0 ;
64170   Dali::Animation result;
64171
64172   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64173   if (!arg2) {
64174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64175     return 0;
64176   }
64177   {
64178     try {
64179       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64180     } catch (std::out_of_range& e) {
64181       {
64182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64183       };
64184     } catch (std::exception& e) {
64185       {
64186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64187       };
64188     } catch (...) {
64189       {
64190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64191       };
64192     }
64193   }
64194   jresult = new Dali::Animation((const Dali::Animation &)result);
64195   return jresult;
64196 }
64197
64198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64199   void * jresult ;
64200   Dali::Toolkit::Control *arg1 = 0 ;
64201   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64202
64203   arg1 = (Dali::Toolkit::Control *)jarg1;
64204   if (!arg1) {
64205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64206     return 0;
64207   }
64208   {
64209     try {
64210       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64211     } catch (std::out_of_range& e) {
64212       {
64213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64214       };
64215     } catch (std::exception& e) {
64216       {
64217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64218       };
64219     } catch (...) {
64220       {
64221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64222       };
64223     }
64224   }
64225   jresult = (void *)result;
64226   return jresult;
64227 }
64228
64229
64230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64231   unsigned int jresult ;
64232   Dali::Toolkit::Control *arg1 = 0 ;
64233   bool result;
64234
64235   arg1 = (Dali::Toolkit::Control *)jarg1;
64236   if (!arg1) {
64237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64238     return 0;
64239   }
64240   {
64241     try {
64242       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64243     } catch (std::out_of_range& e) {
64244       {
64245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64246       };
64247     } catch (std::exception& e) {
64248       {
64249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64250       };
64251     } catch (...) {
64252       {
64253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64254       };
64255     }
64256   }
64257   jresult = result;
64258   return jresult;
64259 }
64260
64261
64262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64263   void * jresult ;
64264   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64265
64266   {
64267     try {
64268       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64269     } catch (std::out_of_range& e) {
64270       {
64271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64272       };
64273     } catch (std::exception& e) {
64274       {
64275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64280       };
64281     }
64282   }
64283   jresult = (void *)result;
64284   return jresult;
64285 }
64286
64287
64288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64289   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64290
64291   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64292   {
64293     try {
64294       delete arg1;
64295     } catch (std::out_of_range& e) {
64296       {
64297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64298       };
64299     } catch (std::exception& e) {
64300       {
64301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64302       };
64303     } catch (...) {
64304       {
64305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64306       };
64307     }
64308   }
64309 }
64310
64311
64312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64313   void * jresult ;
64314   Dali::Toolkit::KeyInputFocusManager result;
64315
64316   {
64317     try {
64318       result = Dali::Toolkit::KeyInputFocusManager::Get();
64319     } catch (std::out_of_range& e) {
64320       {
64321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (std::exception& e) {
64324       {
64325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (...) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64330       };
64331     }
64332   }
64333   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64334   return jresult;
64335 }
64336
64337
64338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64339   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64340   Dali::Toolkit::Control arg2 ;
64341   Dali::Toolkit::Control *argp2 ;
64342
64343   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64344   argp2 = (Dali::Toolkit::Control *)jarg2;
64345   if (!argp2) {
64346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64347     return ;
64348   }
64349   arg2 = *argp2;
64350   {
64351     try {
64352       (arg1)->SetFocus(arg2);
64353     } catch (std::out_of_range& e) {
64354       {
64355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64356       };
64357     } catch (std::exception& e) {
64358       {
64359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64360       };
64361     } catch (...) {
64362       {
64363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64364       };
64365     }
64366   }
64367 }
64368
64369
64370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64371   void * jresult ;
64372   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64373   Dali::Toolkit::Control result;
64374
64375   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64376   {
64377     try {
64378       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64379     } catch (std::out_of_range& e) {
64380       {
64381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64382       };
64383     } catch (std::exception& e) {
64384       {
64385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64386       };
64387     } catch (...) {
64388       {
64389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64390       };
64391     }
64392   }
64393   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64394   return jresult;
64395 }
64396
64397
64398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64399   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64400   Dali::Toolkit::Control arg2 ;
64401   Dali::Toolkit::Control *argp2 ;
64402
64403   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64404   argp2 = (Dali::Toolkit::Control *)jarg2;
64405   if (!argp2) {
64406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64407     return ;
64408   }
64409   arg2 = *argp2;
64410   {
64411     try {
64412       (arg1)->RemoveFocus(arg2);
64413     } catch (std::out_of_range& e) {
64414       {
64415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64416       };
64417     } catch (std::exception& e) {
64418       {
64419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64420       };
64421     } catch (...) {
64422       {
64423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64424       };
64425     }
64426   }
64427 }
64428
64429
64430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64431   void * jresult ;
64432   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64433   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64434
64435   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64436   {
64437     try {
64438       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64439     } catch (std::out_of_range& e) {
64440       {
64441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64442       };
64443     } catch (std::exception& e) {
64444       {
64445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64446       };
64447     } catch (...) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64450       };
64451     }
64452   }
64453   jresult = (void *)result;
64454   return jresult;
64455 }
64456
64457
64458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64459   void * jresult ;
64460   Dali::Toolkit::Alignment::Padding *result = 0 ;
64461
64462   {
64463     try {
64464       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64465     } catch (std::out_of_range& e) {
64466       {
64467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64468       };
64469     } catch (std::exception& e) {
64470       {
64471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64472       };
64473     } catch (...) {
64474       {
64475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64476       };
64477     }
64478   }
64479   jresult = (void *)result;
64480   return jresult;
64481 }
64482
64483
64484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64485   void * jresult ;
64486   float arg1 ;
64487   float arg2 ;
64488   float arg3 ;
64489   float arg4 ;
64490   Dali::Toolkit::Alignment::Padding *result = 0 ;
64491
64492   arg1 = (float)jarg1;
64493   arg2 = (float)jarg2;
64494   arg3 = (float)jarg3;
64495   arg4 = (float)jarg4;
64496   {
64497     try {
64498       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64499     } catch (std::out_of_range& e) {
64500       {
64501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64502       };
64503     } catch (std::exception& e) {
64504       {
64505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64506       };
64507     } catch (...) {
64508       {
64509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64510       };
64511     }
64512   }
64513   jresult = (void *)result;
64514   return jresult;
64515 }
64516
64517
64518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64519   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64520   float arg2 ;
64521
64522   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64523   arg2 = (float)jarg2;
64524   if (arg1) (arg1)->left = arg2;
64525 }
64526
64527
64528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64529   float jresult ;
64530   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64531   float result;
64532
64533   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64534   result = (float) ((arg1)->left);
64535   jresult = result;
64536   return jresult;
64537 }
64538
64539
64540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64541   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64542   float arg2 ;
64543
64544   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64545   arg2 = (float)jarg2;
64546   if (arg1) (arg1)->right = arg2;
64547 }
64548
64549
64550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64551   float jresult ;
64552   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64553   float result;
64554
64555   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64556   result = (float) ((arg1)->right);
64557   jresult = result;
64558   return jresult;
64559 }
64560
64561
64562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64563   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64564   float arg2 ;
64565
64566   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64567   arg2 = (float)jarg2;
64568   if (arg1) (arg1)->top = arg2;
64569 }
64570
64571
64572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64573   float jresult ;
64574   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64575   float result;
64576
64577   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64578   result = (float) ((arg1)->top);
64579   jresult = result;
64580   return jresult;
64581 }
64582
64583
64584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64585   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64586   float arg2 ;
64587
64588   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64589   arg2 = (float)jarg2;
64590   if (arg1) (arg1)->bottom = arg2;
64591 }
64592
64593
64594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64595   float jresult ;
64596   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64597   float result;
64598
64599   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64600   result = (float) ((arg1)->bottom);
64601   jresult = result;
64602   return jresult;
64603 }
64604
64605
64606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64607   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64608
64609   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64610   {
64611     try {
64612       delete arg1;
64613     } catch (std::out_of_range& e) {
64614       {
64615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64616       };
64617     } catch (std::exception& e) {
64618       {
64619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64620       };
64621     } catch (...) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64624       };
64625     }
64626   }
64627 }
64628
64629
64630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64631   void * jresult ;
64632   Dali::Toolkit::Alignment *result = 0 ;
64633
64634   {
64635     try {
64636       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
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_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64657   void * jresult ;
64658   Dali::Toolkit::Alignment::Type arg1 ;
64659   Dali::Toolkit::Alignment::Type arg2 ;
64660   Dali::Toolkit::Alignment result;
64661
64662   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64663   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64664   {
64665     try {
64666       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64667     } catch (std::out_of_range& e) {
64668       {
64669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64670       };
64671     } catch (std::exception& e) {
64672       {
64673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64674       };
64675     } catch (...) {
64676       {
64677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64678       };
64679     }
64680   }
64681   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64682   return jresult;
64683 }
64684
64685
64686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64687   void * jresult ;
64688   Dali::Toolkit::Alignment::Type arg1 ;
64689   Dali::Toolkit::Alignment result;
64690
64691   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64692   {
64693     try {
64694       result = Dali::Toolkit::Alignment::New(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_New__SWIG_2() {
64715   void * jresult ;
64716   Dali::Toolkit::Alignment result;
64717
64718   {
64719     try {
64720       result = Dali::Toolkit::Alignment::New();
64721     } catch (std::out_of_range& e) {
64722       {
64723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64724       };
64725     } catch (std::exception& e) {
64726       {
64727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64728       };
64729     } catch (...) {
64730       {
64731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64732       };
64733     }
64734   }
64735   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64736   return jresult;
64737 }
64738
64739
64740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64741   void * jresult ;
64742   Dali::Toolkit::Alignment *arg1 = 0 ;
64743   Dali::Toolkit::Alignment *result = 0 ;
64744
64745   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64746   if (!arg1) {
64747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64748     return 0;
64749   }
64750   {
64751     try {
64752       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64753     } catch (std::out_of_range& e) {
64754       {
64755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64756       };
64757     } catch (std::exception& e) {
64758       {
64759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64760       };
64761     } catch (...) {
64762       {
64763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64764       };
64765     }
64766   }
64767   jresult = (void *)result;
64768   return jresult;
64769 }
64770
64771
64772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64773   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64774
64775   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64776   {
64777     try {
64778       delete arg1;
64779     } catch (std::out_of_range& e) {
64780       {
64781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64782       };
64783     } catch (std::exception& e) {
64784       {
64785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64786       };
64787     } catch (...) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64790       };
64791     }
64792   }
64793 }
64794
64795
64796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64797   void * jresult ;
64798   Dali::BaseHandle arg1 ;
64799   Dali::BaseHandle *argp1 ;
64800   Dali::Toolkit::Alignment result;
64801
64802   argp1 = (Dali::BaseHandle *)jarg1;
64803   if (!argp1) {
64804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64805     return 0;
64806   }
64807   arg1 = *argp1;
64808   {
64809     try {
64810       result = Dali::Toolkit::Alignment::DownCast(arg1);
64811     } catch (std::out_of_range& e) {
64812       {
64813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64814       };
64815     } catch (std::exception& e) {
64816       {
64817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64818       };
64819     } catch (...) {
64820       {
64821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64822       };
64823     }
64824   }
64825   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64826   return jresult;
64827 }
64828
64829
64830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64831   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64832   Dali::Toolkit::Alignment::Type arg2 ;
64833
64834   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64835   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64836   {
64837     try {
64838       (arg1)->SetAlignmentType(arg2);
64839     } catch (std::out_of_range& e) {
64840       {
64841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64842       };
64843     } catch (std::exception& e) {
64844       {
64845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64846       };
64847     } catch (...) {
64848       {
64849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64850       };
64851     }
64852   }
64853 }
64854
64855
64856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64857   int jresult ;
64858   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64859   Dali::Toolkit::Alignment::Type result;
64860
64861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64862   {
64863     try {
64864       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64865     } catch (std::out_of_range& e) {
64866       {
64867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64868       };
64869     } catch (std::exception& e) {
64870       {
64871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (...) {
64874       {
64875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64876       };
64877     }
64878   }
64879   jresult = (int)result;
64880   return jresult;
64881 }
64882
64883
64884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64885   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64886   Dali::Toolkit::Alignment::Scaling arg2 ;
64887
64888   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64889   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64890   {
64891     try {
64892       (arg1)->SetScaling(arg2);
64893     } catch (std::out_of_range& e) {
64894       {
64895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64896       };
64897     } catch (std::exception& e) {
64898       {
64899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64900       };
64901     } catch (...) {
64902       {
64903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64904       };
64905     }
64906   }
64907 }
64908
64909
64910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64911   int jresult ;
64912   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64913   Dali::Toolkit::Alignment::Scaling result;
64914
64915   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64916   {
64917     try {
64918       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64919     } catch (std::out_of_range& e) {
64920       {
64921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64922       };
64923     } catch (std::exception& e) {
64924       {
64925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64926       };
64927     } catch (...) {
64928       {
64929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64930       };
64931     }
64932   }
64933   jresult = (int)result;
64934   return jresult;
64935 }
64936
64937
64938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64939   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64940   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64941
64942   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64943   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64944   if (!arg2) {
64945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64946     return ;
64947   }
64948   {
64949     try {
64950       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64951     } catch (std::out_of_range& e) {
64952       {
64953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64954       };
64955     } catch (std::exception& e) {
64956       {
64957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64958       };
64959     } catch (...) {
64960       {
64961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64962       };
64963     }
64964   }
64965 }
64966
64967
64968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64969   void * jresult ;
64970   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64971   Dali::Toolkit::Alignment::Padding *result = 0 ;
64972
64973   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64974   {
64975     try {
64976       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64977     } catch (std::out_of_range& e) {
64978       {
64979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64980       };
64981     } catch (std::exception& e) {
64982       {
64983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (...) {
64986       {
64987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64988       };
64989     }
64990   }
64991   jresult = (void *)result;
64992   return jresult;
64993 }
64994
64995
64996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64997   void * jresult ;
64998   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64999   Dali::Toolkit::Alignment *arg2 = 0 ;
65000   Dali::Toolkit::Alignment *result = 0 ;
65001
65002   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65003   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65004   if (!arg2) {
65005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65006     return 0;
65007   }
65008   {
65009     try {
65010       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65011     } catch (std::out_of_range& e) {
65012       {
65013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (std::exception& e) {
65016       {
65017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65018       };
65019     } catch (...) {
65020       {
65021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65022       };
65023     }
65024   }
65025   jresult = (void *)result;
65026   return jresult;
65027 }
65028
65029
65030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65031   int jresult ;
65032   int result;
65033
65034   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65035   jresult = (int)result;
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65041   int jresult ;
65042   int result;
65043
65044   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65045   jresult = (int)result;
65046   return jresult;
65047 }
65048
65049
65050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65051   int jresult ;
65052   int result;
65053
65054   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65055   jresult = (int)result;
65056   return jresult;
65057 }
65058
65059
65060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65061   int jresult ;
65062   int result;
65063
65064   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65065   jresult = (int)result;
65066   return jresult;
65067 }
65068
65069
65070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65071   int jresult ;
65072   int result;
65073
65074   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65075   jresult = (int)result;
65076   return jresult;
65077 }
65078
65079
65080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65081   int jresult ;
65082   int result;
65083
65084   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65085   jresult = (int)result;
65086   return jresult;
65087 }
65088
65089
65090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
65091   int jresult ;
65092   int result;
65093
65094   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
65095   jresult = (int)result;
65096   return jresult;
65097 }
65098
65099
65100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
65101   int jresult ;
65102   int result;
65103
65104   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
65105   jresult = (int)result;
65106   return jresult;
65107 }
65108
65109
65110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65111   int jresult ;
65112   int result;
65113
65114   result = (int)Dali::Toolkit::Button::Property::LABEL;
65115   jresult = (int)result;
65116   return jresult;
65117 }
65118
65119
65120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65121   int jresult ;
65122   int result;
65123
65124   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65125   jresult = (int)result;
65126   return jresult;
65127 }
65128
65129
65130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65131   void * jresult ;
65132   Dali::Toolkit::Button::Property *result = 0 ;
65133
65134   {
65135     try {
65136       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
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_delete_Button_Property(void * jarg1) {
65157   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65158
65159   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65160   {
65161     try {
65162       delete arg1;
65163     } catch (std::out_of_range& e) {
65164       {
65165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65166       };
65167     } catch (std::exception& e) {
65168       {
65169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65170       };
65171     } catch (...) {
65172       {
65173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65174       };
65175     }
65176   }
65177 }
65178
65179
65180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65181   void * jresult ;
65182   Dali::Toolkit::Button *result = 0 ;
65183
65184   {
65185     try {
65186       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65187     } catch (std::out_of_range& e) {
65188       {
65189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65190       };
65191     } catch (std::exception& e) {
65192       {
65193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65194       };
65195     } catch (...) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65198       };
65199     }
65200   }
65201   jresult = (void *)result;
65202   return jresult;
65203 }
65204
65205
65206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65207   void * jresult ;
65208   Dali::Toolkit::Button *arg1 = 0 ;
65209   Dali::Toolkit::Button *result = 0 ;
65210
65211   arg1 = (Dali::Toolkit::Button *)jarg1;
65212   if (!arg1) {
65213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65214     return 0;
65215   }
65216   {
65217     try {
65218       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65219     } catch (std::out_of_range& e) {
65220       {
65221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (std::exception& e) {
65224       {
65225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (...) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65230       };
65231     }
65232   }
65233   jresult = (void *)result;
65234   return jresult;
65235 }
65236
65237
65238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65239   void * jresult ;
65240   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65241   Dali::Toolkit::Button *arg2 = 0 ;
65242   Dali::Toolkit::Button *result = 0 ;
65243
65244   arg1 = (Dali::Toolkit::Button *)jarg1;
65245   arg2 = (Dali::Toolkit::Button *)jarg2;
65246   if (!arg2) {
65247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65248     return 0;
65249   }
65250   {
65251     try {
65252       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65264       };
65265     }
65266   }
65267   jresult = (void *)result;
65268   return jresult;
65269 }
65270
65271
65272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65273   void * jresult ;
65274   Dali::BaseHandle arg1 ;
65275   Dali::BaseHandle *argp1 ;
65276   Dali::Toolkit::Button result;
65277
65278   argp1 = (Dali::BaseHandle *)jarg1;
65279   if (!argp1) {
65280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65281     return 0;
65282   }
65283   arg1 = *argp1;
65284   {
65285     try {
65286       result = Dali::Toolkit::Button::DownCast(arg1);
65287     } catch (std::out_of_range& e) {
65288       {
65289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65290       };
65291     } catch (std::exception& e) {
65292       {
65293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65294       };
65295     } catch (...) {
65296       {
65297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65298       };
65299     }
65300   }
65301   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65302   return jresult;
65303 }
65304
65305
65306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65307   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65308
65309   arg1 = (Dali::Toolkit::Button *)jarg1;
65310   {
65311     try {
65312       delete arg1;
65313     } catch (std::out_of_range& e) {
65314       {
65315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65316       };
65317     } catch (std::exception& e) {
65318       {
65319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65320       };
65321     } catch (...) {
65322       {
65323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65324       };
65325     }
65326   }
65327 }
65328
65329
65330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65331   unsigned int jresult ;
65332   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65333   bool result;
65334
65335   arg1 = (Dali::Toolkit::Button *)jarg1;
65336   {
65337     try {
65338       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65339     } catch (std::out_of_range& e) {
65340       {
65341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (std::exception& e) {
65344       {
65345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65350       };
65351     }
65352   }
65353   jresult = result;
65354   return jresult;
65355 }
65356
65357
65358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65359   unsigned int jresult ;
65360   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65361   bool result;
65362
65363   arg1 = (Dali::Toolkit::Button *)jarg1;
65364   {
65365     try {
65366       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65367     } catch (std::out_of_range& e) {
65368       {
65369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65370       };
65371     } catch (std::exception& e) {
65372       {
65373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65374       };
65375     } catch (...) {
65376       {
65377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65378       };
65379     }
65380   }
65381   jresult = result;
65382   return jresult;
65383 }
65384
65385
65386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65387   float jresult ;
65388   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65389   float result;
65390
65391   arg1 = (Dali::Toolkit::Button *)jarg1;
65392   {
65393     try {
65394       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65395     } catch (std::out_of_range& e) {
65396       {
65397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65398       };
65399     } catch (std::exception& e) {
65400       {
65401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65402       };
65403     } catch (...) {
65404       {
65405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65406       };
65407     }
65408   }
65409   jresult = result;
65410   return jresult;
65411 }
65412
65413
65414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65415   float jresult ;
65416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65417   float result;
65418
65419   arg1 = (Dali::Toolkit::Button *)jarg1;
65420   {
65421     try {
65422       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65423     } catch (std::out_of_range& e) {
65424       {
65425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (std::exception& e) {
65428       {
65429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65430       };
65431     } catch (...) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65434       };
65435     }
65436   }
65437   jresult = result;
65438   return jresult;
65439 }
65440
65441
65442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65443   unsigned int jresult ;
65444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65445   bool result;
65446
65447   arg1 = (Dali::Toolkit::Button *)jarg1;
65448   {
65449     try {
65450       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65451     } catch (std::out_of_range& e) {
65452       {
65453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65454       };
65455     } catch (std::exception& e) {
65456       {
65457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65458       };
65459     } catch (...) {
65460       {
65461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65462       };
65463     }
65464   }
65465   jresult = result;
65466   return jresult;
65467 }
65468
65469
65470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65471   unsigned int jresult ;
65472   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65473   bool result;
65474
65475   arg1 = (Dali::Toolkit::Button *)jarg1;
65476   {
65477     try {
65478       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65479     } catch (std::out_of_range& e) {
65480       {
65481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65482       };
65483     } catch (std::exception& e) {
65484       {
65485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65486       };
65487     } catch (...) {
65488       {
65489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65490       };
65491     }
65492   }
65493   jresult = result;
65494   return jresult;
65495 }
65496
65497
65498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65499   float jresult ;
65500   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65501   float result;
65502
65503   arg1 = (Dali::Toolkit::Button *)jarg1;
65504   {
65505     try {
65506       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65507     } catch (std::out_of_range& e) {
65508       {
65509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65510       };
65511     } catch (std::exception& e) {
65512       {
65513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65514       };
65515     } catch (...) {
65516       {
65517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65518       };
65519     }
65520   }
65521   jresult = result;
65522   return jresult;
65523 }
65524
65525
65526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65527   char * jresult ;
65528   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65529   std::string result;
65530
65531   arg1 = (Dali::Toolkit::Button *)jarg1;
65532   {
65533     try {
65534       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65535     } catch (std::out_of_range& e) {
65536       {
65537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65538       };
65539     } catch (std::exception& e) {
65540       {
65541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65546       };
65547     }
65548   }
65549   jresult = SWIG_csharp_string_callback((&result)->c_str());
65550   return jresult;
65551 }
65552
65553
65554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65555   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65556   Dali::Actor arg2 ;
65557   Dali::Actor *argp2 ;
65558
65559   arg1 = (Dali::Toolkit::Button *)jarg1;
65560   argp2 = (Dali::Actor *)jarg2;
65561   if (!argp2) {
65562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65563     return ;
65564   }
65565   arg2 = *argp2;
65566   {
65567     try {
65568       (arg1)->SetLabel(arg2);
65569     } catch (std::out_of_range& e) {
65570       {
65571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65572       };
65573     } catch (std::exception& e) {
65574       {
65575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65576       };
65577     } catch (...) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65580       };
65581     }
65582   }
65583 }
65584
65585
65586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65587   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65588   Dali::Image arg2 ;
65589   Dali::Image *argp2 ;
65590
65591   arg1 = (Dali::Toolkit::Button *)jarg1;
65592   argp2 = (Dali::Image *)jarg2;
65593   if (!argp2) {
65594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65595     return ;
65596   }
65597   arg2 = *argp2;
65598   {
65599     try {
65600       (arg1)->SetButtonImage(arg2);
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65608       };
65609     } catch (...) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65612       };
65613     }
65614   }
65615 }
65616
65617
65618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65619   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65620   Dali::Image arg2 ;
65621   Dali::Image *argp2 ;
65622
65623   arg1 = (Dali::Toolkit::Button *)jarg1;
65624   argp2 = (Dali::Image *)jarg2;
65625   if (!argp2) {
65626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65627     return ;
65628   }
65629   arg2 = *argp2;
65630   {
65631     try {
65632       (arg1)->SetSelectedImage(arg2);
65633     } catch (std::out_of_range& e) {
65634       {
65635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65636       };
65637     } catch (std::exception& e) {
65638       {
65639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65640       };
65641     } catch (...) {
65642       {
65643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65644       };
65645     }
65646   }
65647 }
65648
65649
65650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65651   void * jresult ;
65652   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65653   Dali::Actor result;
65654
65655   arg1 = (Dali::Toolkit::Button *)jarg1;
65656   {
65657     try {
65658       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673   jresult = new Dali::Actor((const Dali::Actor &)result);
65674   return jresult;
65675 }
65676
65677
65678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65679   void * jresult ;
65680   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65681   Dali::Actor result;
65682
65683   arg1 = (Dali::Toolkit::Button *)jarg1;
65684   {
65685     try {
65686       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65694       };
65695     } catch (...) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65698       };
65699     }
65700   }
65701   jresult = new Dali::Actor((const Dali::Actor &)result);
65702   return jresult;
65703 }
65704
65705
65706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65707   void * jresult ;
65708   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65709   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65710
65711   arg1 = (Dali::Toolkit::Button *)jarg1;
65712   {
65713     try {
65714       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65715     } catch (std::out_of_range& e) {
65716       {
65717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65718       };
65719     } catch (std::exception& e) {
65720       {
65721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65722       };
65723     } catch (...) {
65724       {
65725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65726       };
65727     }
65728   }
65729   jresult = (void *)result;
65730   return jresult;
65731 }
65732
65733
65734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65735   void * jresult ;
65736   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65737   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65738
65739   arg1 = (Dali::Toolkit::Button *)jarg1;
65740   {
65741     try {
65742       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65743     } catch (std::out_of_range& e) {
65744       {
65745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65746       };
65747     } catch (std::exception& e) {
65748       {
65749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65750       };
65751     } catch (...) {
65752       {
65753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65754       };
65755     }
65756   }
65757   jresult = (void *)result;
65758   return jresult;
65759 }
65760
65761
65762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65763   void * jresult ;
65764   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65765   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65766
65767   arg1 = (Dali::Toolkit::Button *)jarg1;
65768   {
65769     try {
65770       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65771     } catch (std::out_of_range& e) {
65772       {
65773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65774       };
65775     } catch (std::exception& e) {
65776       {
65777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65778       };
65779     } catch (...) {
65780       {
65781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65782       };
65783     }
65784   }
65785   jresult = (void *)result;
65786   return jresult;
65787 }
65788
65789
65790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65791   void * jresult ;
65792   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65793   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65794
65795   arg1 = (Dali::Toolkit::Button *)jarg1;
65796   {
65797     try {
65798       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65799     } catch (std::out_of_range& e) {
65800       {
65801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65802       };
65803     } catch (std::exception& e) {
65804       {
65805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65810       };
65811     }
65812   }
65813   jresult = (void *)result;
65814   return jresult;
65815 }
65816
65817
65818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65819   void * jresult ;
65820   Dali::Toolkit::CheckBoxButton *result = 0 ;
65821
65822   {
65823     try {
65824       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
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 = (void *)result;
65840   return jresult;
65841 }
65842
65843
65844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65845   void * jresult ;
65846   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65847   Dali::Toolkit::CheckBoxButton *result = 0 ;
65848
65849   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65850   if (!arg1) {
65851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65852     return 0;
65853   }
65854   {
65855     try {
65856       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65857     } catch (std::out_of_range& e) {
65858       {
65859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65860       };
65861     } catch (std::exception& e) {
65862       {
65863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65864       };
65865     } catch (...) {
65866       {
65867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65868       };
65869     }
65870   }
65871   jresult = (void *)result;
65872   return jresult;
65873 }
65874
65875
65876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65877   void * jresult ;
65878   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65879   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65880   Dali::Toolkit::CheckBoxButton *result = 0 ;
65881
65882   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65883   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65884   if (!arg2) {
65885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65886     return 0;
65887   }
65888   {
65889     try {
65890       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65891     } catch (std::out_of_range& e) {
65892       {
65893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65894       };
65895     } catch (std::exception& e) {
65896       {
65897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65898       };
65899     } catch (...) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65902       };
65903     }
65904   }
65905   jresult = (void *)result;
65906   return jresult;
65907 }
65908
65909
65910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65911   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65912
65913   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65914   {
65915     try {
65916       delete arg1;
65917     } catch (std::out_of_range& e) {
65918       {
65919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65920       };
65921     } catch (std::exception& e) {
65922       {
65923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65924       };
65925     } catch (...) {
65926       {
65927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65928       };
65929     }
65930   }
65931 }
65932
65933
65934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65935   void * jresult ;
65936   Dali::Toolkit::CheckBoxButton result;
65937
65938   {
65939     try {
65940       result = Dali::Toolkit::CheckBoxButton::New();
65941     } catch (std::out_of_range& e) {
65942       {
65943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65944       };
65945     } catch (std::exception& e) {
65946       {
65947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65948       };
65949     } catch (...) {
65950       {
65951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65952       };
65953     }
65954   }
65955   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65956   return jresult;
65957 }
65958
65959
65960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65961   void * jresult ;
65962   Dali::BaseHandle arg1 ;
65963   Dali::BaseHandle *argp1 ;
65964   Dali::Toolkit::CheckBoxButton result;
65965
65966   argp1 = (Dali::BaseHandle *)jarg1;
65967   if (!argp1) {
65968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65969     return 0;
65970   }
65971   arg1 = *argp1;
65972   {
65973     try {
65974       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65975     } catch (std::out_of_range& e) {
65976       {
65977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65978       };
65979     } catch (std::exception& e) {
65980       {
65981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65982       };
65983     } catch (...) {
65984       {
65985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65986       };
65987     }
65988   }
65989   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65990   return jresult;
65991 }
65992
65993
65994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65995   int jresult ;
65996   int result;
65997
65998   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65999   jresult = (int)result;
66000   return jresult;
66001 }
66002
66003
66004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
66005   int jresult ;
66006   int result;
66007
66008   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
66009   jresult = (int)result;
66010   return jresult;
66011 }
66012
66013
66014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66015   int jresult ;
66016   int result;
66017
66018   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
66019   jresult = (int)result;
66020   return jresult;
66021 }
66022
66023
66024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
66025   int jresult ;
66026   int result;
66027
66028   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
66029   jresult = (int)result;
66030   return jresult;
66031 }
66032
66033
66034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
66035   int jresult ;
66036   int result;
66037
66038   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66039   jresult = (int)result;
66040   return jresult;
66041 }
66042
66043
66044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66045   void * jresult ;
66046   Dali::Toolkit::PushButton::Property *result = 0 ;
66047
66048   {
66049     try {
66050       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
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_Property(void * jarg1) {
66071   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66072
66073   arg1 = (Dali::Toolkit::PushButton::Property *)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_new_PushButton__SWIG_0() {
66095   void * jresult ;
66096   Dali::Toolkit::PushButton *result = 0 ;
66097
66098   {
66099     try {
66100       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
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 = (void *)result;
66116   return jresult;
66117 }
66118
66119
66120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66121   void * jresult ;
66122   Dali::Toolkit::PushButton *arg1 = 0 ;
66123   Dali::Toolkit::PushButton *result = 0 ;
66124
66125   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66126   if (!arg1) {
66127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66128     return 0;
66129   }
66130   {
66131     try {
66132       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66133     } catch (std::out_of_range& e) {
66134       {
66135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66136       };
66137     } catch (std::exception& e) {
66138       {
66139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66140       };
66141     } catch (...) {
66142       {
66143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66144       };
66145     }
66146   }
66147   jresult = (void *)result;
66148   return jresult;
66149 }
66150
66151
66152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66153   void * jresult ;
66154   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66155   Dali::Toolkit::PushButton *arg2 = 0 ;
66156   Dali::Toolkit::PushButton *result = 0 ;
66157
66158   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66159   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66160   if (!arg2) {
66161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66162     return 0;
66163   }
66164   {
66165     try {
66166       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66167     } catch (std::out_of_range& e) {
66168       {
66169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66170       };
66171     } catch (std::exception& e) {
66172       {
66173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66174       };
66175     } catch (...) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66178       };
66179     }
66180   }
66181   jresult = (void *)result;
66182   return jresult;
66183 }
66184
66185
66186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66187   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66188
66189   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66190   {
66191     try {
66192       delete arg1;
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66200       };
66201     } catch (...) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66204       };
66205     }
66206   }
66207 }
66208
66209
66210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66211   void * jresult ;
66212   Dali::Toolkit::PushButton result;
66213
66214   {
66215     try {
66216       result = Dali::Toolkit::PushButton::New();
66217     } catch (std::out_of_range& e) {
66218       {
66219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66220       };
66221     } catch (std::exception& e) {
66222       {
66223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66224       };
66225     } catch (...) {
66226       {
66227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66228       };
66229     }
66230   }
66231   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66232   return jresult;
66233 }
66234
66235
66236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66237   void * jresult ;
66238   Dali::BaseHandle arg1 ;
66239   Dali::BaseHandle *argp1 ;
66240   Dali::Toolkit::PushButton result;
66241
66242   argp1 = (Dali::BaseHandle *)jarg1;
66243   if (!argp1) {
66244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66245     return 0;
66246   }
66247   arg1 = *argp1;
66248   {
66249     try {
66250       result = Dali::Toolkit::PushButton::DownCast(arg1);
66251     } catch (std::out_of_range& e) {
66252       {
66253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66254       };
66255     } catch (std::exception& e) {
66256       {
66257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66258       };
66259     } catch (...) {
66260       {
66261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66262       };
66263     }
66264   }
66265   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66266   return jresult;
66267 }
66268
66269
66270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66271   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66272   Dali::Image arg2 ;
66273   Dali::Image *argp2 ;
66274
66275   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66276   argp2 = (Dali::Image *)jarg2;
66277   if (!argp2) {
66278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66279     return ;
66280   }
66281   arg2 = *argp2;
66282   {
66283     try {
66284       (arg1)->SetButtonImage(arg2);
66285     } catch (std::out_of_range& e) {
66286       {
66287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66288       };
66289     } catch (std::exception& e) {
66290       {
66291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66292       };
66293     } catch (...) {
66294       {
66295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66296       };
66297     }
66298   }
66299 }
66300
66301
66302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66303   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66304   Dali::Actor arg2 ;
66305   Dali::Actor *argp2 ;
66306
66307   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66308   argp2 = (Dali::Actor *)jarg2;
66309   if (!argp2) {
66310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66311     return ;
66312   }
66313   arg2 = *argp2;
66314   {
66315     try {
66316       (arg1)->SetButtonImage(arg2);
66317     } catch (std::out_of_range& e) {
66318       {
66319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66320       };
66321     } catch (std::exception& e) {
66322       {
66323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66324       };
66325     } catch (...) {
66326       {
66327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66328       };
66329     }
66330   }
66331 }
66332
66333
66334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66335   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66336   Dali::Actor arg2 ;
66337   Dali::Actor *argp2 ;
66338
66339   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66340   argp2 = (Dali::Actor *)jarg2;
66341   if (!argp2) {
66342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66343     return ;
66344   }
66345   arg2 = *argp2;
66346   {
66347     try {
66348       (arg1)->SetBackgroundImage(arg2);
66349     } catch (std::out_of_range& e) {
66350       {
66351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66352       };
66353     } catch (std::exception& e) {
66354       {
66355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66356       };
66357     } catch (...) {
66358       {
66359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66360       };
66361     }
66362   }
66363 }
66364
66365
66366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66367   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66368   Dali::Image arg2 ;
66369   Dali::Image *argp2 ;
66370
66371   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66372   argp2 = (Dali::Image *)jarg2;
66373   if (!argp2) {
66374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66375     return ;
66376   }
66377   arg2 = *argp2;
66378   {
66379     try {
66380       (arg1)->SetSelectedImage(arg2);
66381     } catch (std::out_of_range& e) {
66382       {
66383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66384       };
66385     } catch (std::exception& e) {
66386       {
66387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66388       };
66389     } catch (...) {
66390       {
66391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66392       };
66393     }
66394   }
66395 }
66396
66397
66398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66399   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66400   Dali::Actor arg2 ;
66401   Dali::Actor *argp2 ;
66402
66403   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66404   argp2 = (Dali::Actor *)jarg2;
66405   if (!argp2) {
66406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66407     return ;
66408   }
66409   arg2 = *argp2;
66410   {
66411     try {
66412       (arg1)->SetSelectedImage(arg2);
66413     } catch (std::out_of_range& e) {
66414       {
66415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66416       };
66417     } catch (std::exception& e) {
66418       {
66419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66420       };
66421     } catch (...) {
66422       {
66423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66424       };
66425     }
66426   }
66427 }
66428
66429
66430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66431   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66432   Dali::Actor arg2 ;
66433   Dali::Actor *argp2 ;
66434
66435   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66436   argp2 = (Dali::Actor *)jarg2;
66437   if (!argp2) {
66438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66439     return ;
66440   }
66441   arg2 = *argp2;
66442   {
66443     try {
66444       (arg1)->SetSelectedBackgroundImage(arg2);
66445     } catch (std::out_of_range& e) {
66446       {
66447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66448       };
66449     } catch (std::exception& e) {
66450       {
66451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66452       };
66453     } catch (...) {
66454       {
66455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66456       };
66457     }
66458   }
66459 }
66460
66461
66462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66463   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66464   Dali::Actor arg2 ;
66465   Dali::Actor *argp2 ;
66466
66467   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66468   argp2 = (Dali::Actor *)jarg2;
66469   if (!argp2) {
66470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66471     return ;
66472   }
66473   arg2 = *argp2;
66474   {
66475     try {
66476       (arg1)->SetDisabledBackgroundImage(arg2);
66477     } catch (std::out_of_range& e) {
66478       {
66479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66480       };
66481     } catch (std::exception& e) {
66482       {
66483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66484       };
66485     } catch (...) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66488       };
66489     }
66490   }
66491 }
66492
66493
66494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66495   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66496   Dali::Actor arg2 ;
66497   Dali::Actor *argp2 ;
66498
66499   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66500   argp2 = (Dali::Actor *)jarg2;
66501   if (!argp2) {
66502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66503     return ;
66504   }
66505   arg2 = *argp2;
66506   {
66507     try {
66508       (arg1)->SetDisabledImage(arg2);
66509     } catch (std::out_of_range& e) {
66510       {
66511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66512       };
66513     } catch (std::exception& e) {
66514       {
66515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66516       };
66517     } catch (...) {
66518       {
66519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66520       };
66521     }
66522   }
66523 }
66524
66525
66526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66527   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66528   Dali::Actor arg2 ;
66529   Dali::Actor *argp2 ;
66530
66531   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66532   argp2 = (Dali::Actor *)jarg2;
66533   if (!argp2) {
66534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66535     return ;
66536   }
66537   arg2 = *argp2;
66538   {
66539     try {
66540       (arg1)->SetDisabledSelectedImage(arg2);
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_new_RadioButton__SWIG_0() {
66559   void * jresult ;
66560   Dali::Toolkit::RadioButton *result = 0 ;
66561
66562   {
66563     try {
66564       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
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 = (void *)result;
66580   return jresult;
66581 }
66582
66583
66584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66585   void * jresult ;
66586   Dali::Toolkit::RadioButton *arg1 = 0 ;
66587   Dali::Toolkit::RadioButton *result = 0 ;
66588
66589   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66590   if (!arg1) {
66591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66592     return 0;
66593   }
66594   {
66595     try {
66596       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66597     } catch (std::out_of_range& e) {
66598       {
66599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66600       };
66601     } catch (std::exception& e) {
66602       {
66603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66604       };
66605     } catch (...) {
66606       {
66607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66608       };
66609     }
66610   }
66611   jresult = (void *)result;
66612   return jresult;
66613 }
66614
66615
66616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66617   void * jresult ;
66618   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66619   Dali::Toolkit::RadioButton *arg2 = 0 ;
66620   Dali::Toolkit::RadioButton *result = 0 ;
66621
66622   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66623   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66624   if (!arg2) {
66625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66626     return 0;
66627   }
66628   {
66629     try {
66630       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66631     } catch (std::out_of_range& e) {
66632       {
66633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66634       };
66635     } catch (std::exception& e) {
66636       {
66637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66638       };
66639     } catch (...) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66642       };
66643     }
66644   }
66645   jresult = (void *)result;
66646   return jresult;
66647 }
66648
66649
66650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66651   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66652
66653   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66654   {
66655     try {
66656       delete arg1;
66657     } catch (std::out_of_range& e) {
66658       {
66659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66660       };
66661     } catch (std::exception& e) {
66662       {
66663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66664       };
66665     } catch (...) {
66666       {
66667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66668       };
66669     }
66670   }
66671 }
66672
66673
66674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66675   void * jresult ;
66676   Dali::Toolkit::RadioButton result;
66677
66678   {
66679     try {
66680       result = Dali::Toolkit::RadioButton::New();
66681     } catch (std::out_of_range& e) {
66682       {
66683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66684       };
66685     } catch (std::exception& e) {
66686       {
66687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66688       };
66689     } catch (...) {
66690       {
66691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66692       };
66693     }
66694   }
66695   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66696   return jresult;
66697 }
66698
66699
66700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66701   void * jresult ;
66702   std::string *arg1 = 0 ;
66703   Dali::Toolkit::RadioButton result;
66704
66705   if (!jarg1) {
66706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66707     return 0;
66708   }
66709   std::string arg1_str(jarg1);
66710   arg1 = &arg1_str;
66711   {
66712     try {
66713       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (...) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66725       };
66726     }
66727   }
66728   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66729
66730   //argout typemap for const std::string&
66731
66732   return jresult;
66733 }
66734
66735
66736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66737   void * jresult ;
66738   Dali::BaseHandle arg1 ;
66739   Dali::BaseHandle *argp1 ;
66740   Dali::Toolkit::RadioButton result;
66741
66742   argp1 = (Dali::BaseHandle *)jarg1;
66743   if (!argp1) {
66744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66745     return 0;
66746   }
66747   arg1 = *argp1;
66748   {
66749     try {
66750       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66751     } catch (std::out_of_range& e) {
66752       {
66753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66754       };
66755     } catch (std::exception& e) {
66756       {
66757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66758       };
66759     } catch (...) {
66760       {
66761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66762       };
66763     }
66764   }
66765   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66766   return jresult;
66767 }
66768
66769
66770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66771   int jresult ;
66772   int result;
66773
66774   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66775   jresult = (int)result;
66776   return jresult;
66777 }
66778
66779
66780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66781   int jresult ;
66782   int result;
66783
66784   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66785   jresult = (int)result;
66786   return jresult;
66787 }
66788
66789
66790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66791   int jresult ;
66792   int result;
66793
66794   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66795   jresult = (int)result;
66796   return jresult;
66797 }
66798
66799
66800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66801   int jresult ;
66802   int result;
66803
66804   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66805   jresult = (int)result;
66806   return jresult;
66807 }
66808
66809
66810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66811   int jresult ;
66812   int result;
66813
66814   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66815   jresult = (int)result;
66816   return jresult;
66817 }
66818
66819
66820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66821   int jresult ;
66822   int result;
66823
66824   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66825   jresult = (int)result;
66826   return jresult;
66827 }
66828
66829
66830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66831   void * jresult ;
66832   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66833
66834   {
66835     try {
66836       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66837     } catch (std::out_of_range& e) {
66838       {
66839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66840       };
66841     } catch (std::exception& e) {
66842       {
66843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66844       };
66845     } catch (...) {
66846       {
66847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66848       };
66849     }
66850   }
66851   jresult = (void *)result;
66852   return jresult;
66853 }
66854
66855
66856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66857   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66858
66859   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66860   {
66861     try {
66862       delete arg1;
66863     } catch (std::out_of_range& e) {
66864       {
66865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66866       };
66867     } catch (std::exception& e) {
66868       {
66869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66870       };
66871     } catch (...) {
66872       {
66873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66874       };
66875     }
66876   }
66877 }
66878
66879
66880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66881   int jresult ;
66882   int result;
66883
66884   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66885   jresult = (int)result;
66886   return jresult;
66887 }
66888
66889
66890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66891   int jresult ;
66892   int result;
66893
66894   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66895   jresult = (int)result;
66896   return jresult;
66897 }
66898
66899
66900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66901   int jresult ;
66902   int result;
66903
66904   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66905   jresult = (int)result;
66906   return jresult;
66907 }
66908
66909
66910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66911   void * jresult ;
66912   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66913
66914   {
66915     try {
66916       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
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_ChildProperty(void * jarg1) {
66937   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66938
66939   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)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_new_FlexContainer__SWIG_0() {
66961   void * jresult ;
66962   Dali::Toolkit::FlexContainer *result = 0 ;
66963
66964   {
66965     try {
66966       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
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 = (void *)result;
66982   return jresult;
66983 }
66984
66985
66986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66987   void * jresult ;
66988   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66989   Dali::Toolkit::FlexContainer *result = 0 ;
66990
66991   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66992   if (!arg1) {
66993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66994     return 0;
66995   }
66996   {
66997     try {
66998       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66999     } catch (std::out_of_range& e) {
67000       {
67001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67002       };
67003     } catch (std::exception& e) {
67004       {
67005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67006       };
67007     } catch (...) {
67008       {
67009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67010       };
67011     }
67012   }
67013   jresult = (void *)result;
67014   return jresult;
67015 }
67016
67017
67018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
67019   void * jresult ;
67020   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67021   Dali::Toolkit::FlexContainer *arg2 = 0 ;
67022   Dali::Toolkit::FlexContainer *result = 0 ;
67023
67024   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67025   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
67026   if (!arg2) {
67027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67028     return 0;
67029   }
67030   {
67031     try {
67032       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
67033     } catch (std::out_of_range& e) {
67034       {
67035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67036       };
67037     } catch (std::exception& e) {
67038       {
67039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67040       };
67041     } catch (...) {
67042       {
67043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67044       };
67045     }
67046   }
67047   jresult = (void *)result;
67048   return jresult;
67049 }
67050
67051
67052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67053   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67054
67055   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67056   {
67057     try {
67058       delete arg1;
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67070       };
67071     }
67072   }
67073 }
67074
67075
67076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67077   void * jresult ;
67078   Dali::Toolkit::FlexContainer result;
67079
67080   {
67081     try {
67082       result = Dali::Toolkit::FlexContainer::New();
67083     } catch (std::out_of_range& e) {
67084       {
67085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67086       };
67087     } catch (std::exception& e) {
67088       {
67089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67090       };
67091     } catch (...) {
67092       {
67093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67094       };
67095     }
67096   }
67097   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67098   return jresult;
67099 }
67100
67101
67102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67103   void * jresult ;
67104   Dali::BaseHandle arg1 ;
67105   Dali::BaseHandle *argp1 ;
67106   Dali::Toolkit::FlexContainer result;
67107
67108   argp1 = (Dali::BaseHandle *)jarg1;
67109   if (!argp1) {
67110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67111     return 0;
67112   }
67113   arg1 = *argp1;
67114   {
67115     try {
67116       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
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 = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67132   return jresult;
67133 }
67134
67135
67136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67137   int jresult ;
67138   int result;
67139
67140   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67141   jresult = (int)result;
67142   return jresult;
67143 }
67144
67145
67146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67147   int jresult ;
67148   int result;
67149
67150   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67151   jresult = (int)result;
67152   return jresult;
67153 }
67154
67155
67156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67157   int jresult ;
67158   int result;
67159
67160   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67161   jresult = (int)result;
67162   return jresult;
67163 }
67164
67165
67166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67167   int jresult ;
67168   int result;
67169
67170   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67171   jresult = (int)result;
67172   return jresult;
67173 }
67174
67175
67176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67177   void * jresult ;
67178   Dali::Toolkit::ImageView::Property *result = 0 ;
67179
67180   {
67181     try {
67182       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197   jresult = (void *)result;
67198   return jresult;
67199 }
67200
67201
67202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67203   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67204
67205   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67206   {
67207     try {
67208       delete arg1;
67209     } catch (std::out_of_range& e) {
67210       {
67211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67212       };
67213     } catch (std::exception& e) {
67214       {
67215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67216       };
67217     } catch (...) {
67218       {
67219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67220       };
67221     }
67222   }
67223 }
67224
67225
67226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67227   void * jresult ;
67228   Dali::Toolkit::ImageView *result = 0 ;
67229
67230   {
67231     try {
67232       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67233     } catch (std::out_of_range& e) {
67234       {
67235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67236       };
67237     } catch (std::exception& e) {
67238       {
67239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67240       };
67241     } catch (...) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67244       };
67245     }
67246   }
67247   jresult = (void *)result;
67248   return jresult;
67249 }
67250
67251
67252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67253   void * jresult ;
67254   Dali::Toolkit::ImageView result;
67255
67256   {
67257     try {
67258       result = Dali::Toolkit::ImageView::New();
67259     } catch (std::out_of_range& e) {
67260       {
67261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67262       };
67263     } catch (std::exception& e) {
67264       {
67265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67266       };
67267     } catch (...) {
67268       {
67269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67270       };
67271     }
67272   }
67273   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67274   return jresult;
67275 }
67276
67277
67278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67279   void * jresult ;
67280   Dali::Image arg1 ;
67281   Dali::Image *argp1 ;
67282   Dali::Toolkit::ImageView result;
67283
67284   argp1 = (Dali::Image *)jarg1;
67285   if (!argp1) {
67286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67287     return 0;
67288   }
67289   arg1 = *argp1;
67290   {
67291     try {
67292       result = Dali::Toolkit::ImageView::New(arg1);
67293     } catch (std::out_of_range& e) {
67294       {
67295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67296       };
67297     } catch (std::exception& e) {
67298       {
67299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67300       };
67301     } catch (...) {
67302       {
67303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67304       };
67305     }
67306   }
67307   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67308   return jresult;
67309 }
67310
67311
67312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67313   void * jresult ;
67314   std::string *arg1 = 0 ;
67315   Dali::Toolkit::ImageView result;
67316
67317   if (!jarg1) {
67318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67319     return 0;
67320   }
67321   std::string arg1_str(jarg1);
67322   arg1 = &arg1_str;
67323   {
67324     try {
67325       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67326     } catch (std::out_of_range& e) {
67327       {
67328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67329       };
67330     } catch (std::exception& e) {
67331       {
67332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67333       };
67334     } catch (...) {
67335       {
67336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67337       };
67338     }
67339   }
67340   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67341
67342   //argout typemap for const std::string&
67343
67344   return jresult;
67345 }
67346
67347
67348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67349   void * jresult ;
67350   std::string *arg1 = 0 ;
67351   Dali::ImageDimensions arg2 ;
67352   Dali::ImageDimensions *argp2 ;
67353   Dali::Toolkit::ImageView result;
67354
67355   if (!jarg1) {
67356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67357     return 0;
67358   }
67359   std::string arg1_str(jarg1);
67360   arg1 = &arg1_str;
67361   argp2 = (Dali::ImageDimensions *)jarg2;
67362   if (!argp2) {
67363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67364     return 0;
67365   }
67366   arg2 = *argp2;
67367   {
67368     try {
67369       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67370     } catch (std::out_of_range& e) {
67371       {
67372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67373       };
67374     } catch (std::exception& e) {
67375       {
67376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67377       };
67378     } catch (...) {
67379       {
67380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67381       };
67382     }
67383   }
67384   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67385
67386   //argout typemap for const std::string&
67387
67388   return jresult;
67389 }
67390
67391
67392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67393   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67394
67395   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67396   {
67397     try {
67398       delete arg1;
67399     } catch (std::out_of_range& e) {
67400       {
67401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67402       };
67403     } catch (std::exception& e) {
67404       {
67405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67406       };
67407     } catch (...) {
67408       {
67409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67410       };
67411     }
67412   }
67413 }
67414
67415
67416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67417   void * jresult ;
67418   Dali::Toolkit::ImageView *arg1 = 0 ;
67419   Dali::Toolkit::ImageView *result = 0 ;
67420
67421   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67422   if (!arg1) {
67423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67424     return 0;
67425   }
67426   {
67427     try {
67428       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67429     } catch (std::out_of_range& e) {
67430       {
67431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67432       };
67433     } catch (std::exception& e) {
67434       {
67435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67436       };
67437     } catch (...) {
67438       {
67439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67440       };
67441     }
67442   }
67443   jresult = (void *)result;
67444   return jresult;
67445 }
67446
67447
67448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67449   void * jresult ;
67450   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67451   Dali::Toolkit::ImageView *arg2 = 0 ;
67452   Dali::Toolkit::ImageView *result = 0 ;
67453
67454   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67455   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67456   if (!arg2) {
67457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67458     return 0;
67459   }
67460   {
67461     try {
67462       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67463     } catch (std::out_of_range& e) {
67464       {
67465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67466       };
67467     } catch (std::exception& e) {
67468       {
67469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (...) {
67472       {
67473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67474       };
67475     }
67476   }
67477   jresult = (void *)result;
67478   return jresult;
67479 }
67480
67481
67482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67483   void * jresult ;
67484   Dali::BaseHandle arg1 ;
67485   Dali::BaseHandle *argp1 ;
67486   Dali::Toolkit::ImageView result;
67487
67488   argp1 = (Dali::BaseHandle *)jarg1;
67489   if (!argp1) {
67490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67491     return 0;
67492   }
67493   arg1 = *argp1;
67494   {
67495     try {
67496       result = Dali::Toolkit::ImageView::DownCast(arg1);
67497     } catch (std::out_of_range& e) {
67498       {
67499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67500       };
67501     } catch (std::exception& e) {
67502       {
67503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67504       };
67505     } catch (...) {
67506       {
67507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67508       };
67509     }
67510   }
67511   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67512   return jresult;
67513 }
67514
67515
67516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67517   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67518   Dali::Image arg2 ;
67519   Dali::Image *argp2 ;
67520
67521   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67522   argp2 = (Dali::Image *)jarg2;
67523   if (!argp2) {
67524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67525     return ;
67526   }
67527   arg2 = *argp2;
67528   {
67529     try {
67530       (arg1)->SetImage(arg2);
67531     } catch (std::out_of_range& e) {
67532       {
67533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67534       };
67535     } catch (std::exception& e) {
67536       {
67537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67538       };
67539     } catch (...) {
67540       {
67541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67542       };
67543     }
67544   }
67545 }
67546
67547
67548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67549   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67550   std::string *arg2 = 0 ;
67551
67552   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67553   if (!jarg2) {
67554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67555     return ;
67556   }
67557   std::string arg2_str(jarg2);
67558   arg2 = &arg2_str;
67559   {
67560     try {
67561       (arg1)->SetImage((std::string const &)*arg2);
67562     } catch (std::out_of_range& e) {
67563       {
67564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67565       };
67566     } catch (std::exception& e) {
67567       {
67568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67569       };
67570     } catch (...) {
67571       {
67572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67573       };
67574     }
67575   }
67576
67577   //argout typemap for const std::string&
67578
67579 }
67580
67581
67582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67583   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67584   std::string *arg2 = 0 ;
67585   Dali::ImageDimensions arg3 ;
67586   Dali::ImageDimensions *argp3 ;
67587
67588   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67589   if (!jarg2) {
67590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67591     return ;
67592   }
67593   std::string arg2_str(jarg2);
67594   arg2 = &arg2_str;
67595   argp3 = (Dali::ImageDimensions *)jarg3;
67596   if (!argp3) {
67597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67598     return ;
67599   }
67600   arg3 = *argp3;
67601   {
67602     try {
67603       (arg1)->SetImage((std::string const &)*arg2,arg3);
67604     } catch (std::out_of_range& e) {
67605       {
67606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67607       };
67608     } catch (std::exception& e) {
67609       {
67610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67611       };
67612     } catch (...) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67615       };
67616     }
67617   }
67618
67619   //argout typemap for const std::string&
67620
67621 }
67622
67623
67624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67625   void * jresult ;
67626   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67627   Dali::Image result;
67628
67629   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67630   {
67631     try {
67632       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67633     } catch (std::out_of_range& e) {
67634       {
67635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67636       };
67637     } catch (std::exception& e) {
67638       {
67639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67640       };
67641     } catch (...) {
67642       {
67643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67644       };
67645     }
67646   }
67647   jresult = new Dali::Image((const Dali::Image &)result);
67648   return jresult;
67649 }
67650
67651
67652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67653   int jresult ;
67654   int result;
67655
67656   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67657   jresult = (int)result;
67658   return jresult;
67659 }
67660
67661
67662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67663   int jresult ;
67664   int result;
67665
67666   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67667   jresult = (int)result;
67668   return jresult;
67669 }
67670
67671
67672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67673   int jresult ;
67674   int result;
67675
67676   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67677   jresult = (int)result;
67678   return jresult;
67679 }
67680
67681
67682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67683   int jresult ;
67684   int result;
67685
67686   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67687   jresult = (int)result;
67688   return jresult;
67689 }
67690
67691
67692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67693   int jresult ;
67694   int result;
67695
67696   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67697   jresult = (int)result;
67698   return jresult;
67699 }
67700
67701
67702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67703   int jresult ;
67704   int result;
67705
67706   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67707   jresult = (int)result;
67708   return jresult;
67709 }
67710
67711
67712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67713   int jresult ;
67714   int result;
67715
67716   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67717   jresult = (int)result;
67718   return jresult;
67719 }
67720
67721
67722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67723   int jresult ;
67724   int result;
67725
67726   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67727   jresult = (int)result;
67728   return jresult;
67729 }
67730
67731
67732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67733   void * jresult ;
67734   Dali::Toolkit::Model3dView::Property *result = 0 ;
67735
67736   {
67737     try {
67738       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67739     } catch (std::out_of_range& e) {
67740       {
67741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67742       };
67743     } catch (std::exception& e) {
67744       {
67745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67746       };
67747     } catch (...) {
67748       {
67749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67750       };
67751     }
67752   }
67753   jresult = (void *)result;
67754   return jresult;
67755 }
67756
67757
67758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67759   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67760
67761   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67762   {
67763     try {
67764       delete arg1;
67765     } catch (std::out_of_range& e) {
67766       {
67767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67768       };
67769     } catch (std::exception& e) {
67770       {
67771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67772       };
67773     } catch (...) {
67774       {
67775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67776       };
67777     }
67778   }
67779 }
67780
67781
67782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67783   void * jresult ;
67784   Dali::Toolkit::Model3dView result;
67785
67786   {
67787     try {
67788       result = Dali::Toolkit::Model3dView::New();
67789     } catch (std::out_of_range& e) {
67790       {
67791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (std::exception& e) {
67794       {
67795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67800       };
67801     }
67802   }
67803   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67804   return jresult;
67805 }
67806
67807
67808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67809   void * jresult ;
67810   std::string *arg1 = 0 ;
67811   std::string *arg2 = 0 ;
67812   std::string *arg3 = 0 ;
67813   Dali::Toolkit::Model3dView result;
67814
67815   if (!jarg1) {
67816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67817     return 0;
67818   }
67819   std::string arg1_str(jarg1);
67820   arg1 = &arg1_str;
67821   if (!jarg2) {
67822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67823     return 0;
67824   }
67825   std::string arg2_str(jarg2);
67826   arg2 = &arg2_str;
67827   if (!jarg3) {
67828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67829     return 0;
67830   }
67831   std::string arg3_str(jarg3);
67832   arg3 = &arg3_str;
67833   {
67834     try {
67835       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67836     } catch (std::out_of_range& e) {
67837       {
67838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (std::exception& e) {
67841       {
67842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (...) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67847       };
67848     }
67849   }
67850   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67851
67852   //argout typemap for const std::string&
67853
67854
67855   //argout typemap for const std::string&
67856
67857
67858   //argout typemap for const std::string&
67859
67860   return jresult;
67861 }
67862
67863
67864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67865   void * jresult ;
67866   Dali::Toolkit::Model3dView *result = 0 ;
67867
67868   {
67869     try {
67870       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67871     } catch (std::out_of_range& e) {
67872       {
67873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67874       };
67875     } catch (std::exception& e) {
67876       {
67877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67878       };
67879     } catch (...) {
67880       {
67881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67882       };
67883     }
67884   }
67885   jresult = (void *)result;
67886   return jresult;
67887 }
67888
67889
67890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67891   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67892
67893   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67894   {
67895     try {
67896       delete arg1;
67897     } catch (std::out_of_range& e) {
67898       {
67899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67900       };
67901     } catch (std::exception& e) {
67902       {
67903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67904       };
67905     } catch (...) {
67906       {
67907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67908       };
67909     }
67910   }
67911 }
67912
67913
67914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67915   void * jresult ;
67916   Dali::Toolkit::Model3dView *arg1 = 0 ;
67917   Dali::Toolkit::Model3dView *result = 0 ;
67918
67919   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67920   if (!arg1) {
67921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67922     return 0;
67923   }
67924   {
67925     try {
67926       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67927     } catch (std::out_of_range& e) {
67928       {
67929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67930       };
67931     } catch (std::exception& e) {
67932       {
67933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67934       };
67935     } catch (...) {
67936       {
67937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67938       };
67939     }
67940   }
67941   jresult = (void *)result;
67942   return jresult;
67943 }
67944
67945
67946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67947   void * jresult ;
67948   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67949   Dali::Toolkit::Model3dView *arg2 = 0 ;
67950   Dali::Toolkit::Model3dView *result = 0 ;
67951
67952   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67953   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67954   if (!arg2) {
67955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67956     return 0;
67957   }
67958   {
67959     try {
67960       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67961     } catch (std::out_of_range& e) {
67962       {
67963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67964       };
67965     } catch (std::exception& e) {
67966       {
67967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67968       };
67969     } catch (...) {
67970       {
67971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67972       };
67973     }
67974   }
67975   jresult = (void *)result;
67976   return jresult;
67977 }
67978
67979
67980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67981   void * jresult ;
67982   Dali::BaseHandle arg1 ;
67983   Dali::BaseHandle *argp1 ;
67984   Dali::Toolkit::Model3dView result;
67985
67986   argp1 = (Dali::BaseHandle *)jarg1;
67987   if (!argp1) {
67988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67989     return 0;
67990   }
67991   arg1 = *argp1;
67992   {
67993     try {
67994       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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 = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68010   return jresult;
68011 }
68012
68013
68014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
68015   int jresult ;
68016   int result;
68017
68018   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
68019   jresult = (int)result;
68020   return jresult;
68021 }
68022
68023
68024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
68025   int jresult ;
68026   int result;
68027
68028   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
68029   jresult = (int)result;
68030   return jresult;
68031 }
68032
68033
68034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
68035   int jresult ;
68036   int result;
68037
68038   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68039   jresult = (int)result;
68040   return jresult;
68041 }
68042
68043
68044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68045   int jresult ;
68046   int result;
68047
68048   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68049   jresult = (int)result;
68050   return jresult;
68051 }
68052
68053
68054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68055   int jresult ;
68056   int result;
68057
68058   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68059   jresult = (int)result;
68060   return jresult;
68061 }
68062
68063
68064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68065   int jresult ;
68066   int result;
68067
68068   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68069   jresult = (int)result;
68070   return jresult;
68071 }
68072
68073
68074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68075   int jresult ;
68076   int result;
68077
68078   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68079   jresult = (int)result;
68080   return jresult;
68081 }
68082
68083
68084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68085   int jresult ;
68086   int result;
68087
68088   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68089   jresult = (int)result;
68090   return jresult;
68091 }
68092
68093
68094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68095   int jresult ;
68096   int result;
68097
68098   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68099   jresult = (int)result;
68100   return jresult;
68101 }
68102
68103
68104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68105   void * jresult ;
68106   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68107
68108   {
68109     try {
68110       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
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_Property(void * jarg1) {
68131   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68132
68133   arg1 = (Dali::Toolkit::ScrollBar::Property *)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_new_ScrollBar__SWIG_0() {
68155   void * jresult ;
68156   Dali::Toolkit::ScrollBar *result = 0 ;
68157
68158   {
68159     try {
68160       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68161     } catch (std::out_of_range& e) {
68162       {
68163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68164       };
68165     } catch (std::exception& e) {
68166       {
68167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68172       };
68173     }
68174   }
68175   jresult = (void *)result;
68176   return jresult;
68177 }
68178
68179
68180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68181   void * jresult ;
68182   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68183   Dali::Toolkit::ScrollBar *result = 0 ;
68184
68185   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68186   if (!arg1) {
68187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68188     return 0;
68189   }
68190   {
68191     try {
68192       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68193     } catch (std::out_of_range& e) {
68194       {
68195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68196       };
68197     } catch (std::exception& e) {
68198       {
68199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68200       };
68201     } catch (...) {
68202       {
68203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68204       };
68205     }
68206   }
68207   jresult = (void *)result;
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68213   void * jresult ;
68214   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68215   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68216   Dali::Toolkit::ScrollBar *result = 0 ;
68217
68218   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68219   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68220   if (!arg2) {
68221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68222     return 0;
68223   }
68224   {
68225     try {
68226       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68227     } catch (std::out_of_range& e) {
68228       {
68229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68230       };
68231     } catch (std::exception& e) {
68232       {
68233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68234       };
68235     } catch (...) {
68236       {
68237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68238       };
68239     }
68240   }
68241   jresult = (void *)result;
68242   return jresult;
68243 }
68244
68245
68246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68247   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68248
68249   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68250   {
68251     try {
68252       delete arg1;
68253     } catch (std::out_of_range& e) {
68254       {
68255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68256       };
68257     } catch (std::exception& e) {
68258       {
68259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68260       };
68261     } catch (...) {
68262       {
68263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68264       };
68265     }
68266   }
68267 }
68268
68269
68270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68271   void * jresult ;
68272   Dali::Toolkit::ScrollBar::Direction arg1 ;
68273   Dali::Toolkit::ScrollBar result;
68274
68275   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68276   {
68277     try {
68278       result = Dali::Toolkit::ScrollBar::New(arg1);
68279     } catch (std::out_of_range& e) {
68280       {
68281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68282       };
68283     } catch (std::exception& e) {
68284       {
68285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68286       };
68287     } catch (...) {
68288       {
68289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68290       };
68291     }
68292   }
68293   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68294   return jresult;
68295 }
68296
68297
68298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68299   void * jresult ;
68300   Dali::Toolkit::ScrollBar result;
68301
68302   {
68303     try {
68304       result = Dali::Toolkit::ScrollBar::New();
68305     } catch (std::out_of_range& e) {
68306       {
68307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68308       };
68309     } catch (std::exception& e) {
68310       {
68311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68312       };
68313     } catch (...) {
68314       {
68315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68316       };
68317     }
68318   }
68319   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68320   return jresult;
68321 }
68322
68323
68324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68325   void * jresult ;
68326   Dali::BaseHandle arg1 ;
68327   Dali::BaseHandle *argp1 ;
68328   Dali::Toolkit::ScrollBar result;
68329
68330   argp1 = (Dali::BaseHandle *)jarg1;
68331   if (!argp1) {
68332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68333     return 0;
68334   }
68335   arg1 = *argp1;
68336   {
68337     try {
68338       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68339     } catch (std::out_of_range& e) {
68340       {
68341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68342       };
68343     } catch (std::exception& e) {
68344       {
68345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68346       };
68347     } catch (...) {
68348       {
68349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68350       };
68351     }
68352   }
68353   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68354   return jresult;
68355 }
68356
68357
68358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68359   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68360   Dali::Handle arg2 ;
68361   Dali::Property::Index arg3 ;
68362   Dali::Property::Index arg4 ;
68363   Dali::Property::Index arg5 ;
68364   Dali::Property::Index arg6 ;
68365   Dali::Handle *argp2 ;
68366
68367   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68368   argp2 = (Dali::Handle *)jarg2;
68369   if (!argp2) {
68370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68371     return ;
68372   }
68373   arg2 = *argp2;
68374   arg3 = (Dali::Property::Index)jarg3;
68375   arg4 = (Dali::Property::Index)jarg4;
68376   arg5 = (Dali::Property::Index)jarg5;
68377   arg6 = (Dali::Property::Index)jarg6;
68378   {
68379     try {
68380       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68381     } catch (std::out_of_range& e) {
68382       {
68383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68384       };
68385     } catch (std::exception& e) {
68386       {
68387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68388       };
68389     } catch (...) {
68390       {
68391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68392       };
68393     }
68394   }
68395 }
68396
68397
68398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68399   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68400   Dali::Actor arg2 ;
68401   Dali::Actor *argp2 ;
68402
68403   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68404   argp2 = (Dali::Actor *)jarg2;
68405   if (!argp2) {
68406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68407     return ;
68408   }
68409   arg2 = *argp2;
68410   {
68411     try {
68412       (arg1)->SetScrollIndicator(arg2);
68413     } catch (std::out_of_range& e) {
68414       {
68415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68416       };
68417     } catch (std::exception& e) {
68418       {
68419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68420       };
68421     } catch (...) {
68422       {
68423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68424       };
68425     }
68426   }
68427 }
68428
68429
68430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68431   void * jresult ;
68432   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68433   Dali::Actor result;
68434
68435   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68436   {
68437     try {
68438       result = (arg1)->GetScrollIndicator();
68439     } catch (std::out_of_range& e) {
68440       {
68441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68442       };
68443     } catch (std::exception& e) {
68444       {
68445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68446       };
68447     } catch (...) {
68448       {
68449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68450       };
68451     }
68452   }
68453   jresult = new Dali::Actor((const Dali::Actor &)result);
68454   return jresult;
68455 }
68456
68457
68458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68459   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68460   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68461
68462   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68463   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68464   if (!arg2) {
68465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68466     return ;
68467   }
68468   {
68469     try {
68470       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68471     } catch (std::out_of_range& e) {
68472       {
68473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68474       };
68475     } catch (std::exception& e) {
68476       {
68477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68478       };
68479     } catch (...) {
68480       {
68481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68482       };
68483     }
68484   }
68485 }
68486
68487
68488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68489   void * jresult ;
68490   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68491   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68492
68493   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68494   {
68495     try {
68496       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68497     } catch (std::out_of_range& e) {
68498       {
68499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (std::exception& e) {
68502       {
68503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68504       };
68505     } catch (...) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68508       };
68509     }
68510   }
68511   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68512   return jresult;
68513 }
68514
68515
68516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68517   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68518   Dali::Toolkit::ScrollBar::Direction arg2 ;
68519
68520   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68521   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68522   {
68523     try {
68524       (arg1)->SetScrollDirection(arg2);
68525     } catch (std::out_of_range& e) {
68526       {
68527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68528       };
68529     } catch (std::exception& e) {
68530       {
68531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68532       };
68533     } catch (...) {
68534       {
68535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68536       };
68537     }
68538   }
68539 }
68540
68541
68542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68543   int jresult ;
68544   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68545   Dali::Toolkit::ScrollBar::Direction result;
68546
68547   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68548   {
68549     try {
68550       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68551     } catch (std::out_of_range& e) {
68552       {
68553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68554       };
68555     } catch (std::exception& e) {
68556       {
68557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68558       };
68559     } catch (...) {
68560       {
68561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68562       };
68563     }
68564   }
68565   jresult = (int)result;
68566   return jresult;
68567 }
68568
68569
68570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68571   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68572   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68573
68574   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68575   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68576   {
68577     try {
68578       (arg1)->SetIndicatorHeightPolicy(arg2);
68579     } catch (std::out_of_range& e) {
68580       {
68581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68582       };
68583     } catch (std::exception& e) {
68584       {
68585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68590       };
68591     }
68592   }
68593 }
68594
68595
68596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68597   int jresult ;
68598   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68599   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68600
68601   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68602   {
68603     try {
68604       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68605     } catch (std::out_of_range& e) {
68606       {
68607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68608       };
68609     } catch (std::exception& e) {
68610       {
68611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68612       };
68613     } catch (...) {
68614       {
68615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68616       };
68617     }
68618   }
68619   jresult = (int)result;
68620   return jresult;
68621 }
68622
68623
68624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68626   float arg2 ;
68627
68628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68629   arg2 = (float)jarg2;
68630   {
68631     try {
68632       (arg1)->SetIndicatorFixedHeight(arg2);
68633     } catch (std::out_of_range& e) {
68634       {
68635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68636       };
68637     } catch (std::exception& e) {
68638       {
68639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68640       };
68641     } catch (...) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68644       };
68645     }
68646   }
68647 }
68648
68649
68650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68651   float jresult ;
68652   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68653   float result;
68654
68655   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68656   {
68657     try {
68658       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68659     } catch (std::out_of_range& e) {
68660       {
68661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68662       };
68663     } catch (std::exception& e) {
68664       {
68665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68666       };
68667     } catch (...) {
68668       {
68669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68670       };
68671     }
68672   }
68673   jresult = result;
68674   return jresult;
68675 }
68676
68677
68678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68679   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68680   float arg2 ;
68681
68682   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68683   arg2 = (float)jarg2;
68684   {
68685     try {
68686       (arg1)->SetIndicatorShowDuration(arg2);
68687     } catch (std::out_of_range& e) {
68688       {
68689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68690       };
68691     } catch (std::exception& e) {
68692       {
68693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68694       };
68695     } catch (...) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68698       };
68699     }
68700   }
68701 }
68702
68703
68704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68705   float jresult ;
68706   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68707   float result;
68708
68709   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68710   {
68711     try {
68712       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68713     } catch (std::out_of_range& e) {
68714       {
68715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68716       };
68717     } catch (std::exception& e) {
68718       {
68719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68720       };
68721     } catch (...) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68724       };
68725     }
68726   }
68727   jresult = result;
68728   return jresult;
68729 }
68730
68731
68732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68733   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68734   float arg2 ;
68735
68736   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68737   arg2 = (float)jarg2;
68738   {
68739     try {
68740       (arg1)->SetIndicatorHideDuration(arg2);
68741     } catch (std::out_of_range& e) {
68742       {
68743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68744       };
68745     } catch (std::exception& e) {
68746       {
68747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68748       };
68749     } catch (...) {
68750       {
68751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68752       };
68753     }
68754   }
68755 }
68756
68757
68758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68759   float jresult ;
68760   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68761   float result;
68762
68763   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68764   {
68765     try {
68766       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68767     } catch (std::out_of_range& e) {
68768       {
68769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68770       };
68771     } catch (std::exception& e) {
68772       {
68773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68774       };
68775     } catch (...) {
68776       {
68777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68778       };
68779     }
68780   }
68781   jresult = result;
68782   return jresult;
68783 }
68784
68785
68786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68787   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68788
68789   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68790   {
68791     try {
68792       (arg1)->ShowIndicator();
68793     } catch (std::out_of_range& e) {
68794       {
68795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68796       };
68797     } catch (std::exception& e) {
68798       {
68799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68800       };
68801     } catch (...) {
68802       {
68803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68804       };
68805     }
68806   }
68807 }
68808
68809
68810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68811   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68812
68813   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68814   {
68815     try {
68816       (arg1)->HideIndicator();
68817     } catch (std::out_of_range& e) {
68818       {
68819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68820       };
68821     } catch (std::exception& e) {
68822       {
68823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68824       };
68825     } catch (...) {
68826       {
68827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68828       };
68829     }
68830   }
68831 }
68832
68833
68834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68835   void * jresult ;
68836   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68837   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68838
68839   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68840   {
68841     try {
68842       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68843     } catch (std::out_of_range& e) {
68844       {
68845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68846       };
68847     } catch (std::exception& e) {
68848       {
68849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68850       };
68851     } catch (...) {
68852       {
68853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68854       };
68855     }
68856   }
68857   jresult = (void *)result;
68858   return jresult;
68859 }
68860
68861
68862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68863   void * jresult ;
68864   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68865   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68866
68867   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68868   {
68869     try {
68870       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68871     } catch (std::out_of_range& e) {
68872       {
68873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68874       };
68875     } catch (std::exception& e) {
68876       {
68877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68882       };
68883     }
68884   }
68885   jresult = (void *)result;
68886   return jresult;
68887 }
68888
68889
68890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68891   int jresult ;
68892   int result;
68893
68894   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68895   jresult = (int)result;
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68901   int jresult ;
68902   int result;
68903
68904   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68905   jresult = (int)result;
68906   return jresult;
68907 }
68908
68909
68910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68911   int jresult ;
68912   int result;
68913
68914   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68915   jresult = (int)result;
68916   return jresult;
68917 }
68918
68919
68920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68921   int jresult ;
68922   int result;
68923
68924   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68925   jresult = (int)result;
68926   return jresult;
68927 }
68928
68929
68930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68931   int jresult ;
68932   int result;
68933
68934   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68935   jresult = (int)result;
68936   return jresult;
68937 }
68938
68939
68940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68941   int jresult ;
68942   int result;
68943
68944   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68945   jresult = (int)result;
68946   return jresult;
68947 }
68948
68949
68950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68951   int jresult ;
68952   int result;
68953
68954   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68955   jresult = (int)result;
68956   return jresult;
68957 }
68958
68959
68960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68961   int jresult ;
68962   int result;
68963
68964   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68965   jresult = (int)result;
68966   return jresult;
68967 }
68968
68969
68970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68971   int jresult ;
68972   int result;
68973
68974   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68975   jresult = (int)result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68981   int jresult ;
68982   int result;
68983
68984   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68985   jresult = (int)result;
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68991   int jresult ;
68992   int result;
68993
68994   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68995   jresult = (int)result;
68996   return jresult;
68997 }
68998
68999
69000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
69001   int jresult ;
69002   int result;
69003
69004   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
69005   jresult = (int)result;
69006   return jresult;
69007 }
69008
69009
69010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
69011   int jresult ;
69012   int result;
69013
69014   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69015   jresult = (int)result;
69016   return jresult;
69017 }
69018
69019
69020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69021   int jresult ;
69022   int result;
69023
69024   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69025   jresult = (int)result;
69026   return jresult;
69027 }
69028
69029
69030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69031   void * jresult ;
69032   Dali::Toolkit::Scrollable::Property *result = 0 ;
69033
69034   {
69035     try {
69036       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
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_Property(void * jarg1) {
69057   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69058
69059   arg1 = (Dali::Toolkit::Scrollable::Property *)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_new_Scrollable__SWIG_0() {
69081   void * jresult ;
69082   Dali::Toolkit::Scrollable *result = 0 ;
69083
69084   {
69085     try {
69086       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69087     } catch (std::out_of_range& e) {
69088       {
69089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69090       };
69091     } catch (std::exception& e) {
69092       {
69093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69094       };
69095     } catch (...) {
69096       {
69097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69098       };
69099     }
69100   }
69101   jresult = (void *)result;
69102   return jresult;
69103 }
69104
69105
69106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69107   void * jresult ;
69108   Dali::Toolkit::Scrollable *arg1 = 0 ;
69109   Dali::Toolkit::Scrollable *result = 0 ;
69110
69111   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69112   if (!arg1) {
69113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69114     return 0;
69115   }
69116   {
69117     try {
69118       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69119     } catch (std::out_of_range& e) {
69120       {
69121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69122       };
69123     } catch (std::exception& e) {
69124       {
69125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69126       };
69127     } catch (...) {
69128       {
69129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69130       };
69131     }
69132   }
69133   jresult = (void *)result;
69134   return jresult;
69135 }
69136
69137
69138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69139   void * jresult ;
69140   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69141   Dali::Toolkit::Scrollable *arg2 = 0 ;
69142   Dali::Toolkit::Scrollable *result = 0 ;
69143
69144   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69145   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69146   if (!arg2) {
69147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69148     return 0;
69149   }
69150   {
69151     try {
69152       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69153     } catch (std::out_of_range& e) {
69154       {
69155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69156       };
69157     } catch (std::exception& e) {
69158       {
69159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69160       };
69161     } catch (...) {
69162       {
69163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69164       };
69165     }
69166   }
69167   jresult = (void *)result;
69168   return jresult;
69169 }
69170
69171
69172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69173   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69174
69175   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69176   {
69177     try {
69178       delete arg1;
69179     } catch (std::out_of_range& e) {
69180       {
69181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69182       };
69183     } catch (std::exception& e) {
69184       {
69185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69186       };
69187     } catch (...) {
69188       {
69189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69190       };
69191     }
69192   }
69193 }
69194
69195
69196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69197   void * jresult ;
69198   Dali::BaseHandle arg1 ;
69199   Dali::BaseHandle *argp1 ;
69200   Dali::Toolkit::Scrollable result;
69201
69202   argp1 = (Dali::BaseHandle *)jarg1;
69203   if (!argp1) {
69204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69205     return 0;
69206   }
69207   arg1 = *argp1;
69208   {
69209     try {
69210       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69211     } catch (std::out_of_range& e) {
69212       {
69213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (std::exception& e) {
69216       {
69217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69226   return jresult;
69227 }
69228
69229
69230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69231   unsigned int jresult ;
69232   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69233   bool result;
69234
69235   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69236   {
69237     try {
69238       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69239     } catch (std::out_of_range& e) {
69240       {
69241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69242       };
69243     } catch (std::exception& e) {
69244       {
69245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69246       };
69247     } catch (...) {
69248       {
69249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69250       };
69251     }
69252   }
69253   jresult = result;
69254   return jresult;
69255 }
69256
69257
69258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69259   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69260   bool arg2 ;
69261
69262   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69263   arg2 = jarg2 ? true : false;
69264   {
69265     try {
69266       (arg1)->SetOvershootEnabled(arg2);
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69274       };
69275     } catch (...) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69278       };
69279     }
69280   }
69281 }
69282
69283
69284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69285   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69286   Dali::Vector4 *arg2 = 0 ;
69287
69288   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69289   arg2 = (Dali::Vector4 *)jarg2;
69290   if (!arg2) {
69291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69292     return ;
69293   }
69294   {
69295     try {
69296       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69297     } catch (std::out_of_range& e) {
69298       {
69299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69300       };
69301     } catch (std::exception& e) {
69302       {
69303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69304       };
69305     } catch (...) {
69306       {
69307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69308       };
69309     }
69310   }
69311 }
69312
69313
69314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69315   void * jresult ;
69316   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69317   Dali::Vector4 result;
69318
69319   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69320   {
69321     try {
69322       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69323     } catch (std::out_of_range& e) {
69324       {
69325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69326       };
69327     } catch (std::exception& e) {
69328       {
69329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69330       };
69331     } catch (...) {
69332       {
69333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69334       };
69335     }
69336   }
69337   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69338   return jresult;
69339 }
69340
69341
69342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69343   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69344   float arg2 ;
69345
69346   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69347   arg2 = (float)jarg2;
69348   {
69349     try {
69350       (arg1)->SetOvershootAnimationSpeed(arg2);
69351     } catch (std::out_of_range& e) {
69352       {
69353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69354       };
69355     } catch (std::exception& e) {
69356       {
69357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69358       };
69359     } catch (...) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69362       };
69363     }
69364   }
69365 }
69366
69367
69368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69369   float jresult ;
69370   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69371   float result;
69372
69373   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69374   {
69375     try {
69376       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69377     } catch (std::out_of_range& e) {
69378       {
69379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (std::exception& e) {
69382       {
69383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (...) {
69386       {
69387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69388       };
69389     }
69390   }
69391   jresult = result;
69392   return jresult;
69393 }
69394
69395
69396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69397   void * jresult ;
69398   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69399   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69400
69401   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69402   {
69403     try {
69404       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (...) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69416       };
69417     }
69418   }
69419   jresult = (void *)result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69425   void * jresult ;
69426   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69427   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69428
69429   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69430   {
69431     try {
69432       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69433     } catch (std::out_of_range& e) {
69434       {
69435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (std::exception& e) {
69438       {
69439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (...) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69444       };
69445     }
69446   }
69447   jresult = (void *)result;
69448   return jresult;
69449 }
69450
69451
69452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69453   void * jresult ;
69454   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69455   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69456
69457   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69458   {
69459     try {
69460       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69461     } catch (std::out_of_range& e) {
69462       {
69463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69464       };
69465     } catch (std::exception& e) {
69466       {
69467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69468       };
69469     } catch (...) {
69470       {
69471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69472       };
69473     }
69474   }
69475   jresult = (void *)result;
69476   return jresult;
69477 }
69478
69479
69480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69481   unsigned int jresult ;
69482   Dali::Toolkit::ControlOrientation::Type arg1 ;
69483   bool result;
69484
69485   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69486   {
69487     try {
69488       result = (bool)Dali::Toolkit::IsVertical(arg1);
69489     } catch (std::out_of_range& e) {
69490       {
69491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (std::exception& e) {
69494       {
69495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (...) {
69498       {
69499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69500       };
69501     }
69502   }
69503   jresult = result;
69504   return jresult;
69505 }
69506
69507
69508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69509   unsigned int jresult ;
69510   Dali::Toolkit::ControlOrientation::Type arg1 ;
69511   bool result;
69512
69513   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69514   {
69515     try {
69516       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69517     } catch (std::out_of_range& e) {
69518       {
69519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69520       };
69521     } catch (std::exception& e) {
69522       {
69523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69524       };
69525     } catch (...) {
69526       {
69527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69528       };
69529     }
69530   }
69531   jresult = result;
69532   return jresult;
69533 }
69534
69535
69536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69537   void * jresult ;
69538   unsigned int arg1 ;
69539   unsigned int arg2 ;
69540   Dali::Toolkit::ItemRange *result = 0 ;
69541
69542   arg1 = (unsigned int)jarg1;
69543   arg2 = (unsigned int)jarg2;
69544   {
69545     try {
69546       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69547     } catch (std::out_of_range& e) {
69548       {
69549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69550       };
69551     } catch (std::exception& e) {
69552       {
69553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69554       };
69555     } catch (...) {
69556       {
69557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69558       };
69559     }
69560   }
69561   jresult = (void *)result;
69562   return jresult;
69563 }
69564
69565
69566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69567   void * jresult ;
69568   Dali::Toolkit::ItemRange *arg1 = 0 ;
69569   Dali::Toolkit::ItemRange *result = 0 ;
69570
69571   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69572   if (!arg1) {
69573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69574     return 0;
69575   }
69576   {
69577     try {
69578       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69579     } catch (std::out_of_range& e) {
69580       {
69581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69582       };
69583     } catch (std::exception& e) {
69584       {
69585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69586       };
69587     } catch (...) {
69588       {
69589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69590       };
69591     }
69592   }
69593   jresult = (void *)result;
69594   return jresult;
69595 }
69596
69597
69598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69599   void * jresult ;
69600   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69601   Dali::Toolkit::ItemRange *arg2 = 0 ;
69602   Dali::Toolkit::ItemRange *result = 0 ;
69603
69604   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69605   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69606   if (!arg2) {
69607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69608     return 0;
69609   }
69610   {
69611     try {
69612       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69613     } catch (std::out_of_range& e) {
69614       {
69615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69616       };
69617     } catch (std::exception& e) {
69618       {
69619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69620       };
69621     } catch (...) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69624       };
69625     }
69626   }
69627   jresult = (void *)result;
69628   return jresult;
69629 }
69630
69631
69632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69633   unsigned int jresult ;
69634   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69635   unsigned int arg2 ;
69636   bool result;
69637
69638   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69639   arg2 = (unsigned int)jarg2;
69640   {
69641     try {
69642       result = (bool)(arg1)->Within(arg2);
69643     } catch (std::out_of_range& e) {
69644       {
69645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69646       };
69647     } catch (std::exception& e) {
69648       {
69649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69650       };
69651     } catch (...) {
69652       {
69653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69654       };
69655     }
69656   }
69657   jresult = result;
69658   return jresult;
69659 }
69660
69661
69662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69663   void * jresult ;
69664   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69665   Dali::Toolkit::ItemRange *arg2 = 0 ;
69666   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69667
69668   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69669   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69670   if (!arg2) {
69671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69672     return 0;
69673   }
69674   {
69675     try {
69676       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69677     } catch (std::out_of_range& e) {
69678       {
69679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69680       };
69681     } catch (std::exception& e) {
69682       {
69683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69684       };
69685     } catch (...) {
69686       {
69687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69688       };
69689     }
69690   }
69691   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69692   return jresult;
69693 }
69694
69695
69696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69697   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69698   unsigned int arg2 ;
69699
69700   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69701   arg2 = (unsigned int)jarg2;
69702   if (arg1) (arg1)->begin = arg2;
69703 }
69704
69705
69706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69707   unsigned int jresult ;
69708   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69709   unsigned int result;
69710
69711   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69712   result = (unsigned int) ((arg1)->begin);
69713   jresult = result;
69714   return jresult;
69715 }
69716
69717
69718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69719   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69720   unsigned int arg2 ;
69721
69722   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69723   arg2 = (unsigned int)jarg2;
69724   if (arg1) (arg1)->end = arg2;
69725 }
69726
69727
69728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69729   unsigned int jresult ;
69730   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69731   unsigned int result;
69732
69733   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69734   result = (unsigned int) ((arg1)->end);
69735   jresult = result;
69736   return jresult;
69737 }
69738
69739
69740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69741   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69742
69743   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69744   {
69745     try {
69746       delete arg1;
69747     } catch (std::out_of_range& e) {
69748       {
69749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69750       };
69751     } catch (std::exception& e) {
69752       {
69753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69754       };
69755     } catch (...) {
69756       {
69757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69758       };
69759     }
69760   }
69761 }
69762
69763
69764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69765   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69766
69767   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69768   {
69769     try {
69770       delete arg1;
69771     } catch (std::out_of_range& e) {
69772       {
69773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69774       };
69775     } catch (std::exception& e) {
69776       {
69777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69778       };
69779     } catch (...) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69782       };
69783     }
69784   }
69785 }
69786
69787
69788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69789   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69790   Dali::Toolkit::ControlOrientation::Type arg2 ;
69791
69792   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69793   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69794   {
69795     try {
69796       (arg1)->SetOrientation(arg2);
69797     } catch (std::out_of_range& e) {
69798       {
69799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69800       };
69801     } catch (std::exception& e) {
69802       {
69803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69804       };
69805     } catch (...) {
69806       {
69807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69808       };
69809     }
69810   }
69811 }
69812
69813
69814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69815   int jresult ;
69816   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69817   Dali::Toolkit::ControlOrientation::Type result;
69818
69819   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69820   {
69821     try {
69822       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69823     } catch (std::out_of_range& e) {
69824       {
69825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69826       };
69827     } catch (std::exception& e) {
69828       {
69829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (...) {
69832       {
69833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69834       };
69835     }
69836   }
69837   jresult = (int)result;
69838   return jresult;
69839 }
69840
69841
69842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69843   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69844   Dali::Property::Map *arg2 = 0 ;
69845
69846   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69847   arg2 = (Dali::Property::Map *)jarg2;
69848   if (!arg2) {
69849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69850     return ;
69851   }
69852   {
69853     try {
69854       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69855     } catch (std::out_of_range& e) {
69856       {
69857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69858       };
69859     } catch (std::exception& e) {
69860       {
69861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69862       };
69863     } catch (...) {
69864       {
69865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69866       };
69867     }
69868   }
69869 }
69870
69871
69872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69873   void * jresult ;
69874   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69875   Dali::Property::Map result;
69876
69877   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69878   {
69879     try {
69880       result = (arg1)->GetLayoutProperties();
69881     } catch (std::out_of_range& e) {
69882       {
69883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69884       };
69885     } catch (std::exception& e) {
69886       {
69887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69888       };
69889     } catch (...) {
69890       {
69891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69892       };
69893     }
69894   }
69895   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69896   return jresult;
69897 }
69898
69899
69900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69901   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69902   unsigned int arg2 ;
69903   Dali::Vector3 *arg3 = 0 ;
69904   Dali::Vector3 *arg4 = 0 ;
69905
69906   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69907   arg2 = (unsigned int)jarg2;
69908   arg3 = (Dali::Vector3 *)jarg3;
69909   if (!arg3) {
69910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69911     return ;
69912   }
69913   arg4 = (Dali::Vector3 *)jarg4;
69914   if (!arg4) {
69915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69916     return ;
69917   }
69918   {
69919     try {
69920       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69921     } catch (std::out_of_range& e) {
69922       {
69923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69924       };
69925     } catch (std::exception& e) {
69926       {
69927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69928       };
69929     } catch (...) {
69930       {
69931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69932       };
69933     }
69934   }
69935 }
69936
69937
69938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69939   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69940   Dali::Vector3 *arg2 = 0 ;
69941
69942   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69943   arg2 = (Dali::Vector3 *)jarg2;
69944   if (!arg2) {
69945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69946     return ;
69947   }
69948   {
69949     try {
69950       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69951     } catch (std::out_of_range& e) {
69952       {
69953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69954       };
69955     } catch (std::exception& e) {
69956       {
69957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69958       };
69959     } catch (...) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69962       };
69963     }
69964   }
69965 }
69966
69967
69968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69969   float jresult ;
69970   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69971   unsigned int arg2 ;
69972   Dali::Vector3 arg3 ;
69973   Dali::Vector3 *argp3 ;
69974   float result;
69975
69976   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69977   arg2 = (unsigned int)jarg2;
69978   argp3 = (Dali::Vector3 *)jarg3;
69979   if (!argp3) {
69980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69981     return 0;
69982   }
69983   arg3 = *argp3;
69984   {
69985     try {
69986       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69987     } catch (std::out_of_range& e) {
69988       {
69989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69990       };
69991     } catch (std::exception& e) {
69992       {
69993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69994       };
69995     } catch (...) {
69996       {
69997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69998       };
69999     }
70000   }
70001   jresult = result;
70002   return jresult;
70003 }
70004
70005
70006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
70007   float jresult ;
70008   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70009   float arg2 ;
70010   float result;
70011
70012   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70013   arg2 = (float)jarg2;
70014   {
70015     try {
70016       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70017     } catch (std::out_of_range& e) {
70018       {
70019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (std::exception& e) {
70022       {
70023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70024       };
70025     } catch (...) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70028       };
70029     }
70030   }
70031   jresult = result;
70032   return jresult;
70033 }
70034
70035
70036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70037   float jresult ;
70038   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70039   unsigned int arg2 ;
70040   float result;
70041
70042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70043   arg2 = (unsigned int)jarg2;
70044   {
70045     try {
70046       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (...) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70058       };
70059     }
70060   }
70061   jresult = result;
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70067   void * jresult ;
70068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70069   float arg2 ;
70070   Dali::Vector3 arg3 ;
70071   Dali::Vector3 *argp3 ;
70072   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70073
70074   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70075   arg2 = (float)jarg2;
70076   argp3 = (Dali::Vector3 *)jarg3;
70077   if (!argp3) {
70078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70079     return 0;
70080   }
70081   arg3 = *argp3;
70082   {
70083     try {
70084       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70085     } catch (std::out_of_range& e) {
70086       {
70087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (std::exception& e) {
70090       {
70091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70092       };
70093     } catch (...) {
70094       {
70095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70096       };
70097     }
70098   }
70099   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70100   return jresult;
70101 }
70102
70103
70104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70105   float jresult ;
70106   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70107   int arg2 ;
70108   float arg3 ;
70109   Dali::Vector3 *arg4 = 0 ;
70110   float result;
70111
70112   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70113   arg2 = (int)jarg2;
70114   arg3 = (float)jarg3;
70115   arg4 = (Dali::Vector3 *)jarg4;
70116   if (!arg4) {
70117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70118     return 0;
70119   }
70120   {
70121     try {
70122       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70123     } catch (std::out_of_range& e) {
70124       {
70125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70126       };
70127     } catch (std::exception& e) {
70128       {
70129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70130       };
70131     } catch (...) {
70132       {
70133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70134       };
70135     }
70136   }
70137   jresult = result;
70138   return jresult;
70139 }
70140
70141
70142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70143   unsigned int jresult ;
70144   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70145   Dali::Vector3 arg2 ;
70146   Dali::Vector3 *argp2 ;
70147   unsigned int result;
70148
70149   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70150   argp2 = (Dali::Vector3 *)jarg2;
70151   if (!argp2) {
70152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70153     return 0;
70154   }
70155   arg2 = *argp2;
70156   {
70157     try {
70158       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70159     } catch (std::out_of_range& e) {
70160       {
70161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70162       };
70163     } catch (std::exception& e) {
70164       {
70165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70170       };
70171     }
70172   }
70173   jresult = result;
70174   return jresult;
70175 }
70176
70177
70178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70179   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70180   unsigned int arg2 ;
70181   Dali::Vector3 *arg3 = 0 ;
70182   Dali::Vector3 *arg4 = 0 ;
70183
70184   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70185   arg2 = (unsigned int)jarg2;
70186   arg3 = (Dali::Vector3 *)jarg3;
70187   if (!arg3) {
70188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70189     return ;
70190   }
70191   arg4 = (Dali::Vector3 *)jarg4;
70192   if (!arg4) {
70193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70194     return ;
70195   }
70196   {
70197     try {
70198       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70199     } catch (std::out_of_range& e) {
70200       {
70201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70202       };
70203     } catch (std::exception& e) {
70204       {
70205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70206       };
70207     } catch (...) {
70208       {
70209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70210       };
70211     }
70212   }
70213 }
70214
70215
70216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70217   void * jresult ;
70218   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70219   Dali::Degree result;
70220
70221   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70222   {
70223     try {
70224       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70225     } catch (std::out_of_range& e) {
70226       {
70227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (std::exception& e) {
70230       {
70231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70232       };
70233     } catch (...) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70236       };
70237     }
70238   }
70239   jresult = new Dali::Degree((const Dali::Degree &)result);
70240   return jresult;
70241 }
70242
70243
70244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70245   float jresult ;
70246   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70247   float result;
70248
70249   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70250   {
70251     try {
70252       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70264       };
70265     }
70266   }
70267   jresult = result;
70268   return jresult;
70269 }
70270
70271
70272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70273   float jresult ;
70274   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70275   float result;
70276
70277   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70278   {
70279     try {
70280       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70281     } catch (std::out_of_range& e) {
70282       {
70283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70284       };
70285     } catch (std::exception& e) {
70286       {
70287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70292       };
70293     }
70294   }
70295   jresult = result;
70296   return jresult;
70297 }
70298
70299
70300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70301   float jresult ;
70302   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70303   float result;
70304
70305   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70306   {
70307     try {
70308       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70309     } catch (std::out_of_range& e) {
70310       {
70311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70312       };
70313     } catch (std::exception& e) {
70314       {
70315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (...) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70320       };
70321     }
70322   }
70323   jresult = result;
70324   return jresult;
70325 }
70326
70327
70328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70329   int jresult ;
70330   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70331   int arg2 ;
70332   int arg3 ;
70333   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70334   bool arg5 ;
70335   int result;
70336
70337   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70338   arg2 = (int)jarg2;
70339   arg3 = (int)jarg3;
70340   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70341   arg5 = jarg5 ? true : false;
70342   {
70343     try {
70344       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70352       };
70353     } catch (...) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70356       };
70357     }
70358   }
70359   jresult = result;
70360   return jresult;
70361 }
70362
70363
70364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70365   float jresult ;
70366   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70367   float result;
70368
70369   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70370   {
70371     try {
70372       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70373     } catch (std::out_of_range& e) {
70374       {
70375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70376       };
70377     } catch (std::exception& e) {
70378       {
70379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70380       };
70381     } catch (...) {
70382       {
70383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70384       };
70385     }
70386   }
70387   jresult = result;
70388   return jresult;
70389 }
70390
70391
70392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70393   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70394   Dali::Actor *arg2 = 0 ;
70395   int arg3 ;
70396   Dali::Vector3 *arg4 = 0 ;
70397   Dali::Actor *arg5 = 0 ;
70398
70399   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70400   arg2 = (Dali::Actor *)jarg2;
70401   if (!arg2) {
70402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70403     return ;
70404   }
70405   arg3 = (int)jarg3;
70406   arg4 = (Dali::Vector3 *)jarg4;
70407   if (!arg4) {
70408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70409     return ;
70410   }
70411   arg5 = (Dali::Actor *)jarg5;
70412   if (!arg5) {
70413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70414     return ;
70415   }
70416   {
70417     try {
70418       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70419     } catch (std::out_of_range& e) {
70420       {
70421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70422       };
70423     } catch (std::exception& e) {
70424       {
70425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70426       };
70427     } catch (...) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70430       };
70431     }
70432   }
70433 }
70434
70435
70436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70437   void * jresult ;
70438   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70439   int arg2 ;
70440   float arg3 ;
70441   Dali::Vector3 *arg4 = 0 ;
70442   Dali::Vector3 result;
70443
70444   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70445   arg2 = (int)jarg2;
70446   arg3 = (float)jarg3;
70447   arg4 = (Dali::Vector3 *)jarg4;
70448   if (!arg4) {
70449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70450     return 0;
70451   }
70452   {
70453     try {
70454       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70455     } catch (std::out_of_range& e) {
70456       {
70457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70458       };
70459     } catch (std::exception& e) {
70460       {
70461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70462       };
70463     } catch (...) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70466       };
70467     }
70468   }
70469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70470   return jresult;
70471 }
70472
70473
70474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70475   void * jresult ;
70476   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70477   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70478
70479   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70480   {
70481     try {
70482       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (...) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70494       };
70495     }
70496   }
70497   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70498   return jresult;
70499 }
70500
70501
70502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70503   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70504
70505   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70506   {
70507     try {
70508       delete arg1;
70509     } catch (std::out_of_range& e) {
70510       {
70511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (std::exception& e) {
70514       {
70515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70516       };
70517     } catch (...) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70520       };
70521     }
70522   }
70523 }
70524
70525
70526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70527   unsigned int jresult ;
70528   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70529   unsigned int result;
70530
70531   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70532   {
70533     try {
70534       result = (unsigned int)(arg1)->GetNumberOfItems();
70535     } catch (std::out_of_range& e) {
70536       {
70537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70538       };
70539     } catch (std::exception& e) {
70540       {
70541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70542       };
70543     } catch (...) {
70544       {
70545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70546       };
70547     }
70548   }
70549   jresult = result;
70550   return jresult;
70551 }
70552
70553
70554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70555   void * jresult ;
70556   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70557   unsigned int arg2 ;
70558   Dali::Actor result;
70559
70560   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70561   arg2 = (unsigned int)jarg2;
70562   {
70563     try {
70564       result = (arg1)->NewItem(arg2);
70565     } catch (std::out_of_range& e) {
70566       {
70567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70568       };
70569     } catch (std::exception& e) {
70570       {
70571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70572       };
70573     } catch (...) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70576       };
70577     }
70578   }
70579   jresult = new Dali::Actor((const Dali::Actor &)result);
70580   return jresult;
70581 }
70582
70583
70584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70585   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70586   unsigned int arg2 ;
70587   Dali::Actor arg3 ;
70588   Dali::Actor *argp3 ;
70589
70590   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70591   arg2 = (unsigned int)jarg2;
70592   argp3 = (Dali::Actor *)jarg3;
70593   if (!argp3) {
70594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70595     return ;
70596   }
70597   arg3 = *argp3;
70598   {
70599     try {
70600       (arg1)->ItemReleased(arg2,arg3);
70601     } catch (std::out_of_range& e) {
70602       {
70603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70604       };
70605     } catch (std::exception& e) {
70606       {
70607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70608       };
70609     } catch (...) {
70610       {
70611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70612       };
70613     }
70614   }
70615 }
70616
70617
70618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70619   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70620   unsigned int arg2 ;
70621   Dali::Actor arg3 ;
70622   Dali::Actor *argp3 ;
70623
70624   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70625   arg2 = (unsigned int)jarg2;
70626   argp3 = (Dali::Actor *)jarg3;
70627   if (!argp3) {
70628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70629     return ;
70630   }
70631   arg3 = *argp3;
70632   {
70633     try {
70634       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70635     } catch (std::out_of_range& e) {
70636       {
70637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70638       };
70639     } catch (std::exception& e) {
70640       {
70641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70642       };
70643     } catch (...) {
70644       {
70645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70646       };
70647     }
70648   }
70649 }
70650
70651
70652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70653   void * jresult ;
70654   Dali::Toolkit::ItemFactory *result = 0 ;
70655
70656   {
70657     try {
70658       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70659     } catch (std::out_of_range& e) {
70660       {
70661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (std::exception& e) {
70664       {
70665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70666       };
70667     } catch (...) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70670       };
70671     }
70672   }
70673   jresult = (void *)result;
70674   return jresult;
70675 }
70676
70677
70678 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) {
70679   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70680   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70681   if (director) {
70682     director->swig_connect_director(callback0, callback1, callback2);
70683   }
70684 }
70685
70686
70687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70688   int jresult ;
70689   int result;
70690
70691   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70692   jresult = (int)result;
70693   return jresult;
70694 }
70695
70696
70697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70698   int jresult ;
70699   int result;
70700
70701   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70702   jresult = (int)result;
70703   return jresult;
70704 }
70705
70706
70707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70708   int jresult ;
70709   int result;
70710
70711   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70712   jresult = (int)result;
70713   return jresult;
70714 }
70715
70716
70717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70718   int jresult ;
70719   int result;
70720
70721   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70722   jresult = (int)result;
70723   return jresult;
70724 }
70725
70726
70727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70728   int jresult ;
70729   int result;
70730
70731   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70732   jresult = (int)result;
70733   return jresult;
70734 }
70735
70736
70737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70738   int jresult ;
70739   int result;
70740
70741   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70742   jresult = (int)result;
70743   return jresult;
70744 }
70745
70746
70747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70748   int jresult ;
70749   int result;
70750
70751   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70752   jresult = (int)result;
70753   return jresult;
70754 }
70755
70756
70757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70758   int jresult ;
70759   int result;
70760
70761   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70762   jresult = (int)result;
70763   return jresult;
70764 }
70765
70766
70767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70768   int jresult ;
70769   int result;
70770
70771   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70772   jresult = (int)result;
70773   return jresult;
70774 }
70775
70776
70777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70778   int jresult ;
70779   int result;
70780
70781   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70782   jresult = (int)result;
70783   return jresult;
70784 }
70785
70786
70787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70788   int jresult ;
70789   int result;
70790
70791   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70792   jresult = (int)result;
70793   return jresult;
70794 }
70795
70796
70797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70798   void * jresult ;
70799   Dali::Toolkit::ItemView::Property *result = 0 ;
70800
70801   {
70802     try {
70803       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
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_Property(void * jarg1) {
70824   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70825
70826   arg1 = (Dali::Toolkit::ItemView::Property *)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_new_ItemView__SWIG_0() {
70848   void * jresult ;
70849   Dali::Toolkit::ItemView *result = 0 ;
70850
70851   {
70852     try {
70853       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70854     } catch (std::out_of_range& e) {
70855       {
70856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70857       };
70858     } catch (std::exception& e) {
70859       {
70860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70861       };
70862     } catch (...) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70865       };
70866     }
70867   }
70868   jresult = (void *)result;
70869   return jresult;
70870 }
70871
70872
70873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70874   void * jresult ;
70875   Dali::Toolkit::ItemView *arg1 = 0 ;
70876   Dali::Toolkit::ItemView *result = 0 ;
70877
70878   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70879   if (!arg1) {
70880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70881     return 0;
70882   }
70883   {
70884     try {
70885       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70886     } catch (std::out_of_range& e) {
70887       {
70888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70889       };
70890     } catch (std::exception& e) {
70891       {
70892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70893       };
70894     } catch (...) {
70895       {
70896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70897       };
70898     }
70899   }
70900   jresult = (void *)result;
70901   return jresult;
70902 }
70903
70904
70905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70906   void * jresult ;
70907   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70908   Dali::Toolkit::ItemView *arg2 = 0 ;
70909   Dali::Toolkit::ItemView *result = 0 ;
70910
70911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70912   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70913   if (!arg2) {
70914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70915     return 0;
70916   }
70917   {
70918     try {
70919       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70920     } catch (std::out_of_range& e) {
70921       {
70922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70923       };
70924     } catch (std::exception& e) {
70925       {
70926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70927       };
70928     } catch (...) {
70929       {
70930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70931       };
70932     }
70933   }
70934   jresult = (void *)result;
70935   return jresult;
70936 }
70937
70938
70939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70941
70942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70943   {
70944     try {
70945       delete arg1;
70946     } catch (std::out_of_range& e) {
70947       {
70948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70949       };
70950     } catch (std::exception& e) {
70951       {
70952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70953       };
70954     } catch (...) {
70955       {
70956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70957       };
70958     }
70959   }
70960 }
70961
70962
70963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70964   void * jresult ;
70965   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70966   Dali::Toolkit::ItemView result;
70967
70968   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70969   if (!arg1) {
70970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70971     return 0;
70972   }
70973   {
70974     try {
70975       result = Dali::Toolkit::ItemView::New(*arg1);
70976     } catch (std::out_of_range& e) {
70977       {
70978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (std::exception& e) {
70981       {
70982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70987       };
70988     }
70989   }
70990   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70991   return jresult;
70992 }
70993
70994
70995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70996   void * jresult ;
70997   Dali::BaseHandle arg1 ;
70998   Dali::BaseHandle *argp1 ;
70999   Dali::Toolkit::ItemView result;
71000
71001   argp1 = (Dali::BaseHandle *)jarg1;
71002   if (!argp1) {
71003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71004     return 0;
71005   }
71006   arg1 = *argp1;
71007   {
71008     try {
71009       result = Dali::Toolkit::ItemView::DownCast(arg1);
71010     } catch (std::out_of_range& e) {
71011       {
71012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71013       };
71014     } catch (std::exception& e) {
71015       {
71016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (...) {
71019       {
71020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71021       };
71022     }
71023   }
71024   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71025   return jresult;
71026 }
71027
71028
71029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71030   unsigned int jresult ;
71031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71032   unsigned int result;
71033
71034   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71035   {
71036     try {
71037       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71038     } catch (std::out_of_range& e) {
71039       {
71040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (std::exception& e) {
71043       {
71044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (...) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71049       };
71050     }
71051   }
71052   jresult = result;
71053   return jresult;
71054 }
71055
71056
71057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71058   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71059   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71060
71061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71062   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71063   if (!arg2) {
71064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71065     return ;
71066   }
71067   {
71068     try {
71069       (arg1)->AddLayout(*arg2);
71070     } catch (std::out_of_range& e) {
71071       {
71072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71073       };
71074     } catch (std::exception& e) {
71075       {
71076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71077       };
71078     } catch (...) {
71079       {
71080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71081       };
71082     }
71083   }
71084 }
71085
71086
71087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71089   unsigned int arg2 ;
71090
71091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71092   arg2 = (unsigned int)jarg2;
71093   {
71094     try {
71095       (arg1)->RemoveLayout(arg2);
71096     } catch (std::out_of_range& e) {
71097       {
71098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71099       };
71100     } catch (std::exception& e) {
71101       {
71102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71103       };
71104     } catch (...) {
71105       {
71106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71107       };
71108     }
71109   }
71110 }
71111
71112
71113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71114   void * jresult ;
71115   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71116   unsigned int arg2 ;
71117   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71118
71119   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71120   arg2 = (unsigned int)jarg2;
71121   {
71122     try {
71123       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71124     } catch (std::out_of_range& e) {
71125       {
71126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71127       };
71128     } catch (std::exception& e) {
71129       {
71130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71131       };
71132     } catch (...) {
71133       {
71134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71135       };
71136     }
71137   }
71138   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71139   return jresult;
71140 }
71141
71142
71143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71144   void * jresult ;
71145   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71146   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71147
71148   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71149   {
71150     try {
71151       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71152     } catch (std::out_of_range& e) {
71153       {
71154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71155       };
71156     } catch (std::exception& e) {
71157       {
71158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71159       };
71160     } catch (...) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71163       };
71164     }
71165   }
71166   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71167   return jresult;
71168 }
71169
71170
71171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71172   float jresult ;
71173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71174   Dali::Toolkit::ItemId arg2 ;
71175   float result;
71176
71177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71178   arg2 = (Dali::Toolkit::ItemId)jarg2;
71179   {
71180     try {
71181       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71182     } catch (std::out_of_range& e) {
71183       {
71184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71185       };
71186     } catch (std::exception& e) {
71187       {
71188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71189       };
71190     } catch (...) {
71191       {
71192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71193       };
71194     }
71195   }
71196   jresult = result;
71197   return jresult;
71198 }
71199
71200
71201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71203   unsigned int arg2 ;
71204   Dali::Vector3 arg3 ;
71205   float arg4 ;
71206   Dali::Vector3 *argp3 ;
71207
71208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71209   arg2 = (unsigned int)jarg2;
71210   argp3 = (Dali::Vector3 *)jarg3;
71211   if (!argp3) {
71212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71213     return ;
71214   }
71215   arg3 = *argp3;
71216   arg4 = (float)jarg4;
71217   {
71218     try {
71219       (arg1)->ActivateLayout(arg2,arg3,arg4);
71220     } catch (std::out_of_range& e) {
71221       {
71222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71223       };
71224     } catch (std::exception& e) {
71225       {
71226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71227       };
71228     } catch (...) {
71229       {
71230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71231       };
71232     }
71233   }
71234 }
71235
71236
71237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71239
71240   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71241   {
71242     try {
71243       (arg1)->DeactivateCurrentLayout();
71244     } catch (std::out_of_range& e) {
71245       {
71246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71247       };
71248     } catch (std::exception& e) {
71249       {
71250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71251       };
71252     } catch (...) {
71253       {
71254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71255       };
71256     }
71257   }
71258 }
71259
71260
71261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71262   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71263   float arg2 ;
71264
71265   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71266   arg2 = (float)jarg2;
71267   {
71268     try {
71269       (arg1)->SetMinimumSwipeSpeed(arg2);
71270     } catch (std::out_of_range& e) {
71271       {
71272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71273       };
71274     } catch (std::exception& e) {
71275       {
71276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71277       };
71278     } catch (...) {
71279       {
71280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71281       };
71282     }
71283   }
71284 }
71285
71286
71287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71288   float jresult ;
71289   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71290   float result;
71291
71292   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71293   {
71294     try {
71295       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71296     } catch (std::out_of_range& e) {
71297       {
71298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71299       };
71300     } catch (std::exception& e) {
71301       {
71302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (...) {
71305       {
71306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71307       };
71308     }
71309   }
71310   jresult = result;
71311   return jresult;
71312 }
71313
71314
71315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71316   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71317   float arg2 ;
71318
71319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71320   arg2 = (float)jarg2;
71321   {
71322     try {
71323       (arg1)->SetMinimumSwipeDistance(arg2);
71324     } catch (std::out_of_range& e) {
71325       {
71326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71327       };
71328     } catch (std::exception& e) {
71329       {
71330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71335       };
71336     }
71337   }
71338 }
71339
71340
71341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71342   float jresult ;
71343   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71344   float result;
71345
71346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71347   {
71348     try {
71349       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71350     } catch (std::out_of_range& e) {
71351       {
71352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71353       };
71354     } catch (std::exception& e) {
71355       {
71356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71357       };
71358     } catch (...) {
71359       {
71360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71361       };
71362     }
71363   }
71364   jresult = result;
71365   return jresult;
71366 }
71367
71368
71369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71371   float arg2 ;
71372
71373   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71374   arg2 = (float)jarg2;
71375   {
71376     try {
71377       (arg1)->SetWheelScrollDistanceStep(arg2);
71378     } catch (std::out_of_range& e) {
71379       {
71380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71381       };
71382     } catch (std::exception& e) {
71383       {
71384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71385       };
71386     } catch (...) {
71387       {
71388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71389       };
71390     }
71391   }
71392 }
71393
71394
71395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71396   float jresult ;
71397   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71398   float result;
71399
71400   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71401   {
71402     try {
71403       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71404     } catch (std::out_of_range& e) {
71405       {
71406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71407       };
71408     } catch (std::exception& e) {
71409       {
71410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71411       };
71412     } catch (...) {
71413       {
71414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71415       };
71416     }
71417   }
71418   jresult = result;
71419   return jresult;
71420 }
71421
71422
71423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71425   bool arg2 ;
71426
71427   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71428   arg2 = jarg2 ? true : false;
71429   {
71430     try {
71431       (arg1)->SetAnchoring(arg2);
71432     } catch (std::out_of_range& e) {
71433       {
71434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71435       };
71436     } catch (std::exception& e) {
71437       {
71438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71439       };
71440     } catch (...) {
71441       {
71442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71443       };
71444     }
71445   }
71446 }
71447
71448
71449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71450   unsigned int jresult ;
71451   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71452   bool result;
71453
71454   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71455   {
71456     try {
71457       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71458     } catch (std::out_of_range& e) {
71459       {
71460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (std::exception& e) {
71463       {
71464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71465       };
71466     } catch (...) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71469       };
71470     }
71471   }
71472   jresult = result;
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71479   float arg2 ;
71480
71481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71482   arg2 = (float)jarg2;
71483   {
71484     try {
71485       (arg1)->SetAnchoringDuration(arg2);
71486     } catch (std::out_of_range& e) {
71487       {
71488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71489       };
71490     } catch (std::exception& e) {
71491       {
71492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71493       };
71494     } catch (...) {
71495       {
71496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71497       };
71498     }
71499   }
71500 }
71501
71502
71503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71504   float jresult ;
71505   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71506   float result;
71507
71508   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71509   {
71510     try {
71511       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71512     } catch (std::out_of_range& e) {
71513       {
71514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71515       };
71516     } catch (std::exception& e) {
71517       {
71518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71519       };
71520     } catch (...) {
71521       {
71522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71523       };
71524     }
71525   }
71526   jresult = result;
71527   return jresult;
71528 }
71529
71530
71531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71532   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71533   Dali::Toolkit::ItemId arg2 ;
71534   float arg3 ;
71535
71536   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71537   arg2 = (Dali::Toolkit::ItemId)jarg2;
71538   arg3 = (float)jarg3;
71539   {
71540     try {
71541       (arg1)->ScrollToItem(arg2,arg3);
71542     } catch (std::out_of_range& e) {
71543       {
71544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71545       };
71546     } catch (std::exception& e) {
71547       {
71548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71549       };
71550     } catch (...) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71553       };
71554     }
71555   }
71556 }
71557
71558
71559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71561   float arg2 ;
71562
71563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71564   arg2 = (float)jarg2;
71565   {
71566     try {
71567       (arg1)->SetRefreshInterval(arg2);
71568     } catch (std::out_of_range& e) {
71569       {
71570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71571       };
71572     } catch (std::exception& e) {
71573       {
71574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71575       };
71576     } catch (...) {
71577       {
71578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71579       };
71580     }
71581   }
71582 }
71583
71584
71585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71586   float jresult ;
71587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71588   float result;
71589
71590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71591   {
71592     try {
71593       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71594     } catch (std::out_of_range& e) {
71595       {
71596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71597       };
71598     } catch (std::exception& e) {
71599       {
71600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71601       };
71602     } catch (...) {
71603       {
71604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71605       };
71606     }
71607   }
71608   jresult = result;
71609   return jresult;
71610 }
71611
71612
71613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71615
71616   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71617   {
71618     try {
71619       (arg1)->Refresh();
71620     } catch (std::out_of_range& e) {
71621       {
71622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71623       };
71624     } catch (std::exception& e) {
71625       {
71626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71627       };
71628     } catch (...) {
71629       {
71630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71631       };
71632     }
71633   }
71634 }
71635
71636
71637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71638   void * jresult ;
71639   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71640   Dali::Toolkit::ItemId arg2 ;
71641   Dali::Actor result;
71642
71643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71644   arg2 = (Dali::Toolkit::ItemId)jarg2;
71645   {
71646     try {
71647       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71648     } catch (std::out_of_range& e) {
71649       {
71650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71651       };
71652     } catch (std::exception& e) {
71653       {
71654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71655       };
71656     } catch (...) {
71657       {
71658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71659       };
71660     }
71661   }
71662   jresult = new Dali::Actor((const Dali::Actor &)result);
71663   return jresult;
71664 }
71665
71666
71667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71668   unsigned int jresult ;
71669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71670   Dali::Actor arg2 ;
71671   Dali::Actor *argp2 ;
71672   Dali::Toolkit::ItemId result;
71673
71674   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71675   argp2 = (Dali::Actor *)jarg2;
71676   if (!argp2) {
71677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71678     return 0;
71679   }
71680   arg2 = *argp2;
71681   {
71682     try {
71683       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71684     } catch (std::out_of_range& e) {
71685       {
71686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71687       };
71688     } catch (std::exception& e) {
71689       {
71690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71691       };
71692     } catch (...) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71695       };
71696     }
71697   }
71698   jresult = result;
71699   return jresult;
71700 }
71701
71702
71703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71705   Dali::Toolkit::Item arg2 ;
71706   float arg3 ;
71707   Dali::Toolkit::Item *argp2 ;
71708
71709   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71710   argp2 = (Dali::Toolkit::Item *)jarg2;
71711   if (!argp2) {
71712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71713     return ;
71714   }
71715   arg2 = *argp2;
71716   arg3 = (float)jarg3;
71717   {
71718     try {
71719       (arg1)->InsertItem(arg2,arg3);
71720     } catch (std::out_of_range& e) {
71721       {
71722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71723       };
71724     } catch (std::exception& e) {
71725       {
71726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71727       };
71728     } catch (...) {
71729       {
71730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71731       };
71732     }
71733   }
71734 }
71735
71736
71737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71738   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71739   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71740   float arg3 ;
71741
71742   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71743   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71744   if (!arg2) {
71745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71746     return ;
71747   }
71748   arg3 = (float)jarg3;
71749   {
71750     try {
71751       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71752     } catch (std::out_of_range& e) {
71753       {
71754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71755       };
71756     } catch (std::exception& e) {
71757       {
71758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71759       };
71760     } catch (...) {
71761       {
71762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71763       };
71764     }
71765   }
71766 }
71767
71768
71769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71770   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71771   Dali::Toolkit::ItemId arg2 ;
71772   float arg3 ;
71773
71774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71775   arg2 = (Dali::Toolkit::ItemId)jarg2;
71776   arg3 = (float)jarg3;
71777   {
71778     try {
71779       (arg1)->RemoveItem(arg2,arg3);
71780     } catch (std::out_of_range& e) {
71781       {
71782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71783       };
71784     } catch (std::exception& e) {
71785       {
71786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71787       };
71788     } catch (...) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71791       };
71792     }
71793   }
71794 }
71795
71796
71797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71799   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71800   float arg3 ;
71801
71802   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71803   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71804   if (!arg2) {
71805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71806     return ;
71807   }
71808   arg3 = (float)jarg3;
71809   {
71810     try {
71811       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71812     } catch (std::out_of_range& e) {
71813       {
71814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71815       };
71816     } catch (std::exception& e) {
71817       {
71818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71819       };
71820     } catch (...) {
71821       {
71822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71823       };
71824     }
71825   }
71826 }
71827
71828
71829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71830   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71831   Dali::Toolkit::Item arg2 ;
71832   float arg3 ;
71833   Dali::Toolkit::Item *argp2 ;
71834
71835   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71836   argp2 = (Dali::Toolkit::Item *)jarg2;
71837   if (!argp2) {
71838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71839     return ;
71840   }
71841   arg2 = *argp2;
71842   arg3 = (float)jarg3;
71843   {
71844     try {
71845       (arg1)->ReplaceItem(arg2,arg3);
71846     } catch (std::out_of_range& e) {
71847       {
71848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71849       };
71850     } catch (std::exception& e) {
71851       {
71852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71853       };
71854     } catch (...) {
71855       {
71856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71857       };
71858     }
71859   }
71860 }
71861
71862
71863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71865   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71866   float arg3 ;
71867
71868   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71869   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71870   if (!arg2) {
71871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71872     return ;
71873   }
71874   arg3 = (float)jarg3;
71875   {
71876     try {
71877       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71878     } catch (std::out_of_range& e) {
71879       {
71880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71881       };
71882     } catch (std::exception& e) {
71883       {
71884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71885       };
71886     } catch (...) {
71887       {
71888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71889       };
71890     }
71891   }
71892 }
71893
71894
71895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71896   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71897   Dali::Vector3 *arg2 = 0 ;
71898
71899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71900   arg2 = (Dali::Vector3 *)jarg2;
71901   if (!arg2) {
71902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71903     return ;
71904   }
71905   {
71906     try {
71907       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*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_GetItemsParentOrigin(void * jarg1) {
71926   void * jresult ;
71927   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71928   Dali::Vector3 result;
71929
71930   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71931   {
71932     try {
71933       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
71949   return jresult;
71950 }
71951
71952
71953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71954   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71955   Dali::Vector3 *arg2 = 0 ;
71956
71957   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71958   arg2 = (Dali::Vector3 *)jarg2;
71959   if (!arg2) {
71960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71961     return ;
71962   }
71963   {
71964     try {
71965       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71966     } catch (std::out_of_range& e) {
71967       {
71968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71969       };
71970     } catch (std::exception& e) {
71971       {
71972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71973       };
71974     } catch (...) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71977       };
71978     }
71979   }
71980 }
71981
71982
71983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71984   void * jresult ;
71985   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71986   Dali::Vector3 result;
71987
71988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71989   {
71990     try {
71991       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71992     } catch (std::out_of_range& e) {
71993       {
71994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71995       };
71996     } catch (std::exception& e) {
71997       {
71998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71999       };
72000     } catch (...) {
72001       {
72002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72003       };
72004     }
72005   }
72006   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72007   return jresult;
72008 }
72009
72010
72011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72012   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72013   Dali::Toolkit::ItemRange *arg2 = 0 ;
72014
72015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72016   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72017   if (!arg2) {
72018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72019     return ;
72020   }
72021   {
72022     try {
72023       (arg1)->GetItemsRange(*arg2);
72024     } catch (std::out_of_range& e) {
72025       {
72026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72027       };
72028     } catch (std::exception& e) {
72029       {
72030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72031       };
72032     } catch (...) {
72033       {
72034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72035       };
72036     }
72037   }
72038 }
72039
72040
72041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72042   void * jresult ;
72043   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72044   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72045
72046   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72047   {
72048     try {
72049       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72050     } catch (std::out_of_range& e) {
72051       {
72052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72053       };
72054     } catch (std::exception& e) {
72055       {
72056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72057       };
72058     } catch (...) {
72059       {
72060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72061       };
72062     }
72063   }
72064   jresult = (void *)result;
72065   return jresult;
72066 }
72067
72068
72069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72070   Dali::Vector3 *arg1 = 0 ;
72071   PropertyInputContainer *arg2 = 0 ;
72072
72073   arg1 = (Dali::Vector3 *)jarg1;
72074   if (!arg1) {
72075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72076     return ;
72077   }
72078   arg2 = (PropertyInputContainer *)jarg2;
72079   if (!arg2) {
72080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72081     return ;
72082   }
72083   {
72084     try {
72085       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72086     } catch (std::out_of_range& e) {
72087       {
72088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72089       };
72090     } catch (std::exception& e) {
72091       {
72092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72093       };
72094     } catch (...) {
72095       {
72096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72097       };
72098     }
72099   }
72100 }
72101
72102
72103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72104   Dali::Vector3 *arg1 = 0 ;
72105   PropertyInputContainer *arg2 = 0 ;
72106
72107   arg1 = (Dali::Vector3 *)jarg1;
72108   if (!arg1) {
72109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72110     return ;
72111   }
72112   arg2 = (PropertyInputContainer *)jarg2;
72113   if (!arg2) {
72114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72115     return ;
72116   }
72117   {
72118     try {
72119       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72120     } catch (std::out_of_range& e) {
72121       {
72122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72123       };
72124     } catch (std::exception& e) {
72125       {
72126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72127       };
72128     } catch (...) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72131       };
72132     }
72133   }
72134 }
72135
72136
72137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72138   void * jresult ;
72139   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72140
72141   {
72142     try {
72143       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72144     } catch (std::out_of_range& e) {
72145       {
72146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72147       };
72148     } catch (std::exception& e) {
72149       {
72150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72151       };
72152     } catch (...) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72155       };
72156     }
72157   }
72158   jresult = (void *)result;
72159   return jresult;
72160 }
72161
72162
72163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72164   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72165
72166   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72167   {
72168     try {
72169       delete arg1;
72170     } catch (std::out_of_range& e) {
72171       {
72172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72173       };
72174     } catch (std::exception& e) {
72175       {
72176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72177       };
72178     } catch (...) {
72179       {
72180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72181       };
72182     }
72183   }
72184 }
72185
72186
72187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72188   void * jresult ;
72189   Dali::Path arg1 ;
72190   Dali::Vector3 *arg2 = 0 ;
72191   Dali::Property::Index arg3 ;
72192   Dali::Vector3 *arg4 = 0 ;
72193   unsigned int arg5 ;
72194   Dali::Path *argp1 ;
72195   Dali::Toolkit::ScrollViewPagePathEffect result;
72196
72197   argp1 = (Dali::Path *)jarg1;
72198   if (!argp1) {
72199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72200     return 0;
72201   }
72202   arg1 = *argp1;
72203   arg2 = (Dali::Vector3 *)jarg2;
72204   if (!arg2) {
72205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72206     return 0;
72207   }
72208   arg3 = (Dali::Property::Index)jarg3;
72209   arg4 = (Dali::Vector3 *)jarg4;
72210   if (!arg4) {
72211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72212     return 0;
72213   }
72214   arg5 = (unsigned int)jarg5;
72215   {
72216     try {
72217       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72218     } catch (std::out_of_range& e) {
72219       {
72220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72221       };
72222     } catch (std::exception& e) {
72223       {
72224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72225       };
72226     } catch (...) {
72227       {
72228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72229       };
72230     }
72231   }
72232   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72233   return jresult;
72234 }
72235
72236
72237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72238   void * jresult ;
72239   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72240
72241   {
72242     try {
72243       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72244     } catch (std::out_of_range& e) {
72245       {
72246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (std::exception& e) {
72249       {
72250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (...) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72255       };
72256     }
72257   }
72258   jresult = (void *)result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72264   void * jresult ;
72265   Dali::BaseHandle arg1 ;
72266   Dali::BaseHandle *argp1 ;
72267   Dali::Toolkit::ScrollViewPagePathEffect result;
72268
72269   argp1 = (Dali::BaseHandle *)jarg1;
72270   if (!argp1) {
72271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72272     return 0;
72273   }
72274   arg1 = *argp1;
72275   {
72276     try {
72277       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72278     } catch (std::out_of_range& e) {
72279       {
72280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72281       };
72282     } catch (std::exception& e) {
72283       {
72284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72285       };
72286     } catch (...) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72289       };
72290     }
72291   }
72292   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72293   return jresult;
72294 }
72295
72296
72297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72298   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72299   Dali::Actor arg2 ;
72300   unsigned int arg3 ;
72301   Dali::Actor *argp2 ;
72302
72303   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72304   argp2 = (Dali::Actor *)jarg2;
72305   if (!argp2) {
72306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72307     return ;
72308   }
72309   arg2 = *argp2;
72310   arg3 = (unsigned int)jarg3;
72311   {
72312     try {
72313       (arg1)->ApplyToPage(arg2,arg3);
72314     } catch (std::out_of_range& e) {
72315       {
72316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72317       };
72318     } catch (std::exception& e) {
72319       {
72320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72321       };
72322     } catch (...) {
72323       {
72324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72325       };
72326     }
72327   }
72328 }
72329
72330
72331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72332   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72333
72334   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72335   {
72336     try {
72337       delete arg1;
72338     } catch (std::out_of_range& e) {
72339       {
72340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72341       };
72342     } catch (std::exception& e) {
72343       {
72344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72345       };
72346     } catch (...) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72349       };
72350     }
72351   }
72352 }
72353
72354
72355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72356   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72357   Dali::Toolkit::ClampState arg2 ;
72358
72359   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72360   arg2 = (Dali::Toolkit::ClampState)jarg2;
72361   if (arg1) (arg1)->x = arg2;
72362 }
72363
72364
72365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72366   int jresult ;
72367   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72368   Dali::Toolkit::ClampState result;
72369
72370   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72371   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72372   jresult = (int)result;
72373   return jresult;
72374 }
72375
72376
72377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72378   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72379   Dali::Toolkit::ClampState arg2 ;
72380
72381   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72382   arg2 = (Dali::Toolkit::ClampState)jarg2;
72383   if (arg1) (arg1)->y = arg2;
72384 }
72385
72386
72387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72388   int jresult ;
72389   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72390   Dali::Toolkit::ClampState result;
72391
72392   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72393   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72394   jresult = (int)result;
72395   return jresult;
72396 }
72397
72398
72399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72400   void * jresult ;
72401   Dali::Toolkit::ClampState2D *result = 0 ;
72402
72403   {
72404     try {
72405       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72406     } catch (std::out_of_range& e) {
72407       {
72408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72409       };
72410     } catch (std::exception& e) {
72411       {
72412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72413       };
72414     } catch (...) {
72415       {
72416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72417       };
72418     }
72419   }
72420   jresult = (void *)result;
72421   return jresult;
72422 }
72423
72424
72425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72426   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72427
72428   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72429   {
72430     try {
72431       delete arg1;
72432     } catch (std::out_of_range& e) {
72433       {
72434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72435       };
72436     } catch (std::exception& e) {
72437       {
72438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72439       };
72440     } catch (...) {
72441       {
72442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72443       };
72444     }
72445   }
72446 }
72447
72448
72449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72450   void * jresult ;
72451   float arg1 ;
72452   float arg2 ;
72453   bool arg3 ;
72454   Dali::Toolkit::RulerDomain *result = 0 ;
72455
72456   arg1 = (float)jarg1;
72457   arg2 = (float)jarg2;
72458   arg3 = jarg3 ? true : false;
72459   {
72460     try {
72461       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72462     } catch (std::out_of_range& e) {
72463       {
72464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72465       };
72466     } catch (std::exception& e) {
72467       {
72468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72469       };
72470     } catch (...) {
72471       {
72472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72473       };
72474     }
72475   }
72476   jresult = (void *)result;
72477   return jresult;
72478 }
72479
72480
72481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72482   void * jresult ;
72483   float arg1 ;
72484   float arg2 ;
72485   Dali::Toolkit::RulerDomain *result = 0 ;
72486
72487   arg1 = (float)jarg1;
72488   arg2 = (float)jarg2;
72489   {
72490     try {
72491       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72492     } catch (std::out_of_range& e) {
72493       {
72494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72495       };
72496     } catch (std::exception& e) {
72497       {
72498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72499       };
72500     } catch (...) {
72501       {
72502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72503       };
72504     }
72505   }
72506   jresult = (void *)result;
72507   return jresult;
72508 }
72509
72510
72511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72512   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72513   float arg2 ;
72514
72515   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72516   arg2 = (float)jarg2;
72517   if (arg1) (arg1)->min = arg2;
72518 }
72519
72520
72521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72522   float jresult ;
72523   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72524   float result;
72525
72526   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72527   result = (float) ((arg1)->min);
72528   jresult = result;
72529   return jresult;
72530 }
72531
72532
72533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72534   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72535   float arg2 ;
72536
72537   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72538   arg2 = (float)jarg2;
72539   if (arg1) (arg1)->max = arg2;
72540 }
72541
72542
72543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72544   float jresult ;
72545   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72546   float result;
72547
72548   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72549   result = (float) ((arg1)->max);
72550   jresult = result;
72551   return jresult;
72552 }
72553
72554
72555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72556   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72557   bool arg2 ;
72558
72559   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72560   arg2 = jarg2 ? true : false;
72561   if (arg1) (arg1)->enabled = arg2;
72562 }
72563
72564
72565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72566   unsigned int jresult ;
72567   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72568   bool result;
72569
72570   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72571   result = (bool) ((arg1)->enabled);
72572   jresult = result;
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72578   float jresult ;
72579   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72580   float arg2 ;
72581   float arg3 ;
72582   float arg4 ;
72583   float result;
72584
72585   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72586   arg2 = (float)jarg2;
72587   arg3 = (float)jarg3;
72588   arg4 = (float)jarg4;
72589   {
72590     try {
72591       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72592     } catch (std::out_of_range& e) {
72593       {
72594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72595       };
72596     } catch (std::exception& e) {
72597       {
72598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72599       };
72600     } catch (...) {
72601       {
72602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72603       };
72604     }
72605   }
72606   jresult = result;
72607   return jresult;
72608 }
72609
72610
72611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72612   float jresult ;
72613   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72614   float arg2 ;
72615   float arg3 ;
72616   float result;
72617
72618   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72619   arg2 = (float)jarg2;
72620   arg3 = (float)jarg3;
72621   {
72622     try {
72623       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72624     } catch (std::out_of_range& e) {
72625       {
72626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72627       };
72628     } catch (std::exception& e) {
72629       {
72630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72631       };
72632     } catch (...) {
72633       {
72634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72635       };
72636     }
72637   }
72638   jresult = result;
72639   return jresult;
72640 }
72641
72642
72643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72644   float jresult ;
72645   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72646   float arg2 ;
72647   float result;
72648
72649   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72650   arg2 = (float)jarg2;
72651   {
72652     try {
72653       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72654     } catch (std::out_of_range& e) {
72655       {
72656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72657       };
72658     } catch (std::exception& e) {
72659       {
72660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72661       };
72662     } catch (...) {
72663       {
72664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72665       };
72666     }
72667   }
72668   jresult = result;
72669   return jresult;
72670 }
72671
72672
72673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72674   float jresult ;
72675   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72676   float arg2 ;
72677   float arg3 ;
72678   float arg4 ;
72679   Dali::Toolkit::ClampState *arg5 = 0 ;
72680   float result;
72681
72682   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72683   arg2 = (float)jarg2;
72684   arg3 = (float)jarg3;
72685   arg4 = (float)jarg4;
72686   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72687   if (!arg5) {
72688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72689     return 0;
72690   }
72691   {
72692     try {
72693       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72694     } catch (std::out_of_range& e) {
72695       {
72696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72697       };
72698     } catch (std::exception& e) {
72699       {
72700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72701       };
72702     } catch (...) {
72703       {
72704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72705       };
72706     }
72707   }
72708   jresult = result;
72709   return jresult;
72710 }
72711
72712
72713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72714   float jresult ;
72715   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72716   float result;
72717
72718   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72719   {
72720     try {
72721       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72722     } catch (std::out_of_range& e) {
72723       {
72724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72725       };
72726     } catch (std::exception& e) {
72727       {
72728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (...) {
72731       {
72732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72733       };
72734     }
72735   }
72736   jresult = result;
72737   return jresult;
72738 }
72739
72740
72741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72742   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72743
72744   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72745   {
72746     try {
72747       delete arg1;
72748     } catch (std::out_of_range& e) {
72749       {
72750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72751       };
72752     } catch (std::exception& e) {
72753       {
72754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72755       };
72756     } catch (...) {
72757       {
72758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72759       };
72760     }
72761   }
72762 }
72763
72764
72765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72766   float jresult ;
72767   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72768   float arg2 ;
72769   float arg3 ;
72770   float result;
72771
72772   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72773   arg2 = (float)jarg2;
72774   arg3 = (float)jarg3;
72775   {
72776     try {
72777       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72789       };
72790     }
72791   }
72792   jresult = result;
72793   return jresult;
72794 }
72795
72796
72797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72798   float jresult ;
72799   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72800   float arg2 ;
72801   float result;
72802
72803   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72804   arg2 = (float)jarg2;
72805   {
72806     try {
72807       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72808     } catch (std::out_of_range& e) {
72809       {
72810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72811       };
72812     } catch (std::exception& e) {
72813       {
72814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72815       };
72816     } catch (...) {
72817       {
72818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72819       };
72820     }
72821   }
72822   jresult = result;
72823   return jresult;
72824 }
72825
72826
72827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72828   float jresult ;
72829   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72830   unsigned int arg2 ;
72831   unsigned int *arg3 = 0 ;
72832   bool arg4 ;
72833   float result;
72834
72835   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72836   arg2 = (unsigned int)jarg2;
72837   arg3 = (unsigned int *)jarg3;
72838   arg4 = jarg4 ? true : false;
72839   {
72840     try {
72841       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
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 unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72862   unsigned int jresult ;
72863   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72864   float arg2 ;
72865   bool arg3 ;
72866   unsigned int result;
72867
72868   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72869   arg2 = (float)jarg2;
72870   arg3 = jarg3 ? true : false;
72871   {
72872     try {
72873       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72874     } catch (std::out_of_range& e) {
72875       {
72876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72877       };
72878     } catch (std::exception& e) {
72879       {
72880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72881       };
72882     } catch (...) {
72883       {
72884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72885       };
72886     }
72887   }
72888   jresult = result;
72889   return jresult;
72890 }
72891
72892
72893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72894   unsigned int jresult ;
72895   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72896   unsigned int result;
72897
72898   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72899   {
72900     try {
72901       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72902     } catch (std::out_of_range& e) {
72903       {
72904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72905       };
72906     } catch (std::exception& e) {
72907       {
72908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72909       };
72910     } catch (...) {
72911       {
72912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72913       };
72914     }
72915   }
72916   jresult = result;
72917   return jresult;
72918 }
72919
72920
72921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72922   int jresult ;
72923   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72924   Dali::Toolkit::Ruler::RulerType result;
72925
72926   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72927   {
72928     try {
72929       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72930     } catch (std::out_of_range& e) {
72931       {
72932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72933       };
72934     } catch (std::exception& e) {
72935       {
72936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72937       };
72938     } catch (...) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72941       };
72942     }
72943   }
72944   jresult = (int)result;
72945   return jresult;
72946 }
72947
72948
72949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72950   unsigned int jresult ;
72951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72952   bool result;
72953
72954   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72955   {
72956     try {
72957       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72958     } catch (std::out_of_range& e) {
72959       {
72960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72961       };
72962     } catch (std::exception& e) {
72963       {
72964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (...) {
72967       {
72968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72969       };
72970     }
72971   }
72972   jresult = result;
72973   return jresult;
72974 }
72975
72976
72977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72978   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72979
72980   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72981   {
72982     try {
72983       (arg1)->Enable();
72984     } catch (std::out_of_range& e) {
72985       {
72986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72987       };
72988     } catch (std::exception& e) {
72989       {
72990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72991       };
72992     } catch (...) {
72993       {
72994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72995       };
72996     }
72997   }
72998 }
72999
73000
73001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73002   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73003
73004   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73005   {
73006     try {
73007       (arg1)->Disable();
73008     } catch (std::out_of_range& e) {
73009       {
73010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73011       };
73012     } catch (std::exception& e) {
73013       {
73014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73015       };
73016     } catch (...) {
73017       {
73018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73019       };
73020     }
73021   }
73022 }
73023
73024
73025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73026   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73027   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73028   Dali::Toolkit::RulerDomain *argp2 ;
73029
73030   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73031   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73032   if (!argp2) {
73033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73034     return ;
73035   }
73036   arg2 = *argp2;
73037   {
73038     try {
73039       (arg1)->SetDomain(arg2);
73040     } catch (std::out_of_range& e) {
73041       {
73042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73043       };
73044     } catch (std::exception& e) {
73045       {
73046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73047       };
73048     } catch (...) {
73049       {
73050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73051       };
73052     }
73053   }
73054 }
73055
73056
73057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73058   void * jresult ;
73059   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73060   Dali::Toolkit::RulerDomain *result = 0 ;
73061
73062   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73063   {
73064     try {
73065       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (...) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73077       };
73078     }
73079   }
73080   jresult = (void *)result;
73081   return jresult;
73082 }
73083
73084
73085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73086   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73087
73088   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73089   {
73090     try {
73091       (arg1)->DisableDomain();
73092     } catch (std::out_of_range& e) {
73093       {
73094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73095       };
73096     } catch (std::exception& e) {
73097       {
73098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73099       };
73100     } catch (...) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73103       };
73104     }
73105   }
73106 }
73107
73108
73109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73110   float jresult ;
73111   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73112   float arg2 ;
73113   float arg3 ;
73114   float arg4 ;
73115   float result;
73116
73117   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73118   arg2 = (float)jarg2;
73119   arg3 = (float)jarg3;
73120   arg4 = (float)jarg4;
73121   {
73122     try {
73123       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73124     } catch (std::out_of_range& e) {
73125       {
73126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (std::exception& e) {
73129       {
73130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73131       };
73132     } catch (...) {
73133       {
73134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73135       };
73136     }
73137   }
73138   jresult = result;
73139   return jresult;
73140 }
73141
73142
73143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73144   float jresult ;
73145   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73146   float arg2 ;
73147   float arg3 ;
73148   float result;
73149
73150   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73151   arg2 = (float)jarg2;
73152   arg3 = (float)jarg3;
73153   {
73154     try {
73155       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73156     } catch (std::out_of_range& e) {
73157       {
73158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73159       };
73160     } catch (std::exception& e) {
73161       {
73162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73163       };
73164     } catch (...) {
73165       {
73166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73167       };
73168     }
73169   }
73170   jresult = result;
73171   return jresult;
73172 }
73173
73174
73175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73176   float jresult ;
73177   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73178   float arg2 ;
73179   float result;
73180
73181   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73182   arg2 = (float)jarg2;
73183   {
73184     try {
73185       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73186     } catch (std::out_of_range& e) {
73187       {
73188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73189       };
73190     } catch (std::exception& e) {
73191       {
73192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73193       };
73194     } catch (...) {
73195       {
73196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73197       };
73198     }
73199   }
73200   jresult = result;
73201   return jresult;
73202 }
73203
73204
73205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73206   float jresult ;
73207   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73208   float arg2 ;
73209   float arg3 ;
73210   float arg4 ;
73211   Dali::Toolkit::ClampState *arg5 = 0 ;
73212   float result;
73213
73214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73215   arg2 = (float)jarg2;
73216   arg3 = (float)jarg3;
73217   arg4 = (float)jarg4;
73218   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73219   if (!arg5) {
73220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73221     return 0;
73222   }
73223   {
73224     try {
73225       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73226     } catch (std::out_of_range& e) {
73227       {
73228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73229       };
73230     } catch (std::exception& e) {
73231       {
73232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73233       };
73234     } catch (...) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73237       };
73238     }
73239   }
73240   jresult = result;
73241   return jresult;
73242 }
73243
73244
73245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73246   float jresult ;
73247   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73248   float arg2 ;
73249   float arg3 ;
73250   float arg4 ;
73251   float arg5 ;
73252   float result;
73253
73254   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73255   arg2 = (float)jarg2;
73256   arg3 = (float)jarg3;
73257   arg4 = (float)jarg4;
73258   arg5 = (float)jarg5;
73259   {
73260     try {
73261       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73262     } catch (std::out_of_range& e) {
73263       {
73264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73265       };
73266     } catch (std::exception& e) {
73267       {
73268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73269       };
73270     } catch (...) {
73271       {
73272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73273       };
73274     }
73275   }
73276   jresult = result;
73277   return jresult;
73278 }
73279
73280
73281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73282   float jresult ;
73283   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73284   float arg2 ;
73285   float arg3 ;
73286   float arg4 ;
73287   float result;
73288
73289   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73290   arg2 = (float)jarg2;
73291   arg3 = (float)jarg3;
73292   arg4 = (float)jarg4;
73293   {
73294     try {
73295       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73296     } catch (std::out_of_range& e) {
73297       {
73298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73299       };
73300     } catch (std::exception& e) {
73301       {
73302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73303       };
73304     } catch (...) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73307       };
73308     }
73309   }
73310   jresult = result;
73311   return jresult;
73312 }
73313
73314
73315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73316   float jresult ;
73317   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73318   float arg2 ;
73319   float arg3 ;
73320   float result;
73321
73322   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73323   arg2 = (float)jarg2;
73324   arg3 = (float)jarg3;
73325   {
73326     try {
73327       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73328     } catch (std::out_of_range& e) {
73329       {
73330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73331       };
73332     } catch (std::exception& e) {
73333       {
73334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73335       };
73336     } catch (...) {
73337       {
73338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73339       };
73340     }
73341   }
73342   jresult = result;
73343   return jresult;
73344 }
73345
73346
73347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73348   float jresult ;
73349   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73350   float arg2 ;
73351   float result;
73352
73353   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73354   arg2 = (float)jarg2;
73355   {
73356     try {
73357       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73358     } catch (std::out_of_range& e) {
73359       {
73360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73361       };
73362     } catch (std::exception& e) {
73363       {
73364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73365       };
73366     } catch (...) {
73367       {
73368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73369       };
73370     }
73371   }
73372   jresult = result;
73373   return jresult;
73374 }
73375
73376
73377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73378   float jresult ;
73379   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73380   float arg2 ;
73381   float arg3 ;
73382   float arg4 ;
73383   float arg5 ;
73384   Dali::Toolkit::ClampState *arg6 = 0 ;
73385   float result;
73386
73387   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73388   arg2 = (float)jarg2;
73389   arg3 = (float)jarg3;
73390   arg4 = (float)jarg4;
73391   arg5 = (float)jarg5;
73392   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73393   if (!arg6) {
73394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73395     return 0;
73396   }
73397   {
73398     try {
73399       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73400     } catch (std::out_of_range& e) {
73401       {
73402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73403       };
73404     } catch (std::exception& e) {
73405       {
73406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73407       };
73408     } catch (...) {
73409       {
73410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73411       };
73412     }
73413   }
73414   jresult = result;
73415   return jresult;
73416 }
73417
73418
73419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73420   void * jresult ;
73421   Dali::Toolkit::DefaultRuler *result = 0 ;
73422
73423   {
73424     try {
73425       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440   jresult = (void *)result;
73441   return jresult;
73442 }
73443
73444
73445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73446   float jresult ;
73447   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73448   float arg2 ;
73449   float arg3 ;
73450   float result;
73451
73452   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73453   arg2 = (float)jarg2;
73454   arg3 = (float)jarg3;
73455   {
73456     try {
73457       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73458     } catch (std::out_of_range& e) {
73459       {
73460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73461       };
73462     } catch (std::exception& e) {
73463       {
73464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73465       };
73466     } catch (...) {
73467       {
73468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73469       };
73470     }
73471   }
73472   jresult = result;
73473   return jresult;
73474 }
73475
73476
73477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73478   float jresult ;
73479   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73480   unsigned int arg2 ;
73481   unsigned int *arg3 = 0 ;
73482   bool arg4 ;
73483   float result;
73484
73485   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73486   arg2 = (unsigned int)jarg2;
73487   arg3 = (unsigned int *)jarg3;
73488   arg4 = jarg4 ? true : false;
73489   {
73490     try {
73491       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73492     } catch (std::out_of_range& e) {
73493       {
73494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73495       };
73496     } catch (std::exception& e) {
73497       {
73498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73499       };
73500     } catch (...) {
73501       {
73502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73503       };
73504     }
73505   }
73506   jresult = result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73512   unsigned int jresult ;
73513   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73514   float arg2 ;
73515   bool arg3 ;
73516   unsigned int result;
73517
73518   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73519   arg2 = (float)jarg2;
73520   arg3 = jarg3 ? true : false;
73521   {
73522     try {
73523       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73524     } catch (std::out_of_range& e) {
73525       {
73526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (std::exception& e) {
73529       {
73530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73531       };
73532     } catch (...) {
73533       {
73534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73535       };
73536     }
73537   }
73538   jresult = result;
73539   return jresult;
73540 }
73541
73542
73543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73544   unsigned int jresult ;
73545   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73546   unsigned int result;
73547
73548   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73549   {
73550     try {
73551       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73552     } catch (std::out_of_range& e) {
73553       {
73554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73555       };
73556     } catch (std::exception& e) {
73557       {
73558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (...) {
73561       {
73562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73563       };
73564     }
73565   }
73566   jresult = result;
73567   return jresult;
73568 }
73569
73570
73571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73572   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73573
73574   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73575   {
73576     try {
73577       delete arg1;
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73585       };
73586     } catch (...) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73589       };
73590     }
73591   }
73592 }
73593
73594
73595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73596   void * jresult ;
73597   float arg1 ;
73598   Dali::Toolkit::FixedRuler *result = 0 ;
73599
73600   arg1 = (float)jarg1;
73601   {
73602     try {
73603       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73604     } catch (std::out_of_range& e) {
73605       {
73606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (std::exception& e) {
73609       {
73610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73615       };
73616     }
73617   }
73618   jresult = (void *)result;
73619   return jresult;
73620 }
73621
73622
73623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73624   void * jresult ;
73625   Dali::Toolkit::FixedRuler *result = 0 ;
73626
73627   {
73628     try {
73629       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73630     } catch (std::out_of_range& e) {
73631       {
73632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73633       };
73634     } catch (std::exception& e) {
73635       {
73636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73637       };
73638     } catch (...) {
73639       {
73640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73641       };
73642     }
73643   }
73644   jresult = (void *)result;
73645   return jresult;
73646 }
73647
73648
73649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73650   float jresult ;
73651   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73652   float arg2 ;
73653   float arg3 ;
73654   float result;
73655
73656   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73657   arg2 = (float)jarg2;
73658   arg3 = (float)jarg3;
73659   {
73660     try {
73661       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73662     } catch (std::out_of_range& e) {
73663       {
73664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73665       };
73666     } catch (std::exception& e) {
73667       {
73668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73669       };
73670     } catch (...) {
73671       {
73672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73673       };
73674     }
73675   }
73676   jresult = result;
73677   return jresult;
73678 }
73679
73680
73681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73682   float jresult ;
73683   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73684   unsigned int arg2 ;
73685   unsigned int *arg3 = 0 ;
73686   bool arg4 ;
73687   float result;
73688
73689   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73690   arg2 = (unsigned int)jarg2;
73691   arg3 = (unsigned int *)jarg3;
73692   arg4 = jarg4 ? true : false;
73693   {
73694     try {
73695       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73696     } catch (std::out_of_range& e) {
73697       {
73698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73699       };
73700     } catch (std::exception& e) {
73701       {
73702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73703       };
73704     } catch (...) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73707       };
73708     }
73709   }
73710   jresult = result;
73711   return jresult;
73712 }
73713
73714
73715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73716   unsigned int jresult ;
73717   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73718   float arg2 ;
73719   bool arg3 ;
73720   unsigned int result;
73721
73722   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73723   arg2 = (float)jarg2;
73724   arg3 = jarg3 ? true : false;
73725   {
73726     try {
73727       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73728     } catch (std::out_of_range& e) {
73729       {
73730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73731       };
73732     } catch (std::exception& e) {
73733       {
73734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73735       };
73736     } catch (...) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73739       };
73740     }
73741   }
73742   jresult = result;
73743   return jresult;
73744 }
73745
73746
73747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73748   unsigned int jresult ;
73749   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73750   unsigned int result;
73751
73752   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73753   {
73754     try {
73755       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
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 = result;
73771   return jresult;
73772 }
73773
73774
73775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73776   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73777
73778   arg1 = (Dali::Toolkit::FixedRuler *)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_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73800   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73801   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73802
73803   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73804   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73805   if (arg1) (arg1)->scale = *arg2;
73806 }
73807
73808
73809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73810   void * jresult ;
73811   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73812   Dali::Toolkit::ClampState2D *result = 0 ;
73813
73814   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73815   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73816   jresult = (void *)result;
73817   return jresult;
73818 }
73819
73820
73821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73822   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73823   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73824
73825   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73826   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73827   if (arg1) (arg1)->position = *arg2;
73828 }
73829
73830
73831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73832   void * jresult ;
73833   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73834   Dali::Toolkit::ClampState2D *result = 0 ;
73835
73836   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73837   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73838   jresult = (void *)result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73844   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73845   Dali::Toolkit::ClampState arg2 ;
73846
73847   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73848   arg2 = (Dali::Toolkit::ClampState)jarg2;
73849   if (arg1) (arg1)->rotation = arg2;
73850 }
73851
73852
73853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73854   int jresult ;
73855   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73856   Dali::Toolkit::ClampState result;
73857
73858   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73859   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73860   jresult = (int)result;
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73866   void * jresult ;
73867   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73868
73869   {
73870     try {
73871       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
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_ClampEvent(void * jarg1) {
73892   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73893
73894   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)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 void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73916   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73917   Dali::Toolkit::SnapType arg2 ;
73918
73919   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73920   arg2 = (Dali::Toolkit::SnapType)jarg2;
73921   if (arg1) (arg1)->type = arg2;
73922 }
73923
73924
73925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73926   int jresult ;
73927   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73928   Dali::Toolkit::SnapType result;
73929
73930   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73931   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73932   jresult = (int)result;
73933   return jresult;
73934 }
73935
73936
73937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73938   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73939   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73940
73941   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73942   arg2 = (Dali::Vector2 *)jarg2;
73943   if (arg1) (arg1)->position = *arg2;
73944 }
73945
73946
73947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73948   void * jresult ;
73949   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73950   Dali::Vector2 *result = 0 ;
73951
73952   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73953   result = (Dali::Vector2 *)& ((arg1)->position);
73954   jresult = (void *)result;
73955   return jresult;
73956 }
73957
73958
73959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73960   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73961   float arg2 ;
73962
73963   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73964   arg2 = (float)jarg2;
73965   if (arg1) (arg1)->duration = arg2;
73966 }
73967
73968
73969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73970   float jresult ;
73971   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73972   float result;
73973
73974   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73975   result = (float) ((arg1)->duration);
73976   jresult = result;
73977   return jresult;
73978 }
73979
73980
73981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73982   void * jresult ;
73983   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73984
73985   {
73986     try {
73987       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73988     } catch (std::out_of_range& e) {
73989       {
73990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (std::exception& e) {
73993       {
73994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002   jresult = (void *)result;
74003   return jresult;
74004 }
74005
74006
74007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74008   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74009
74010   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74011   {
74012     try {
74013       delete arg1;
74014     } catch (std::out_of_range& e) {
74015       {
74016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74017       };
74018     } catch (std::exception& e) {
74019       {
74020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74021       };
74022     } catch (...) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74025       };
74026     }
74027   }
74028 }
74029
74030
74031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74032   int jresult ;
74033   int result;
74034
74035   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74036   jresult = (int)result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74042   int jresult ;
74043   int result;
74044
74045   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74046   jresult = (int)result;
74047   return jresult;
74048 }
74049
74050
74051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74052   int jresult ;
74053   int result;
74054
74055   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74056   jresult = (int)result;
74057   return jresult;
74058 }
74059
74060
74061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74062   int jresult ;
74063   int result;
74064
74065   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74066   jresult = (int)result;
74067   return jresult;
74068 }
74069
74070
74071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74072   int jresult ;
74073   int result;
74074
74075   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
74076   jresult = (int)result;
74077   return jresult;
74078 }
74079
74080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74081   int jresult ;
74082   int result;
74083
74084   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74085   jresult = (int)result;
74086   return jresult;
74087 }
74088
74089
74090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74091   int jresult ;
74092   int result;
74093
74094   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74095   jresult = (int)result;
74096   return jresult;
74097 }
74098
74099
74100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74101   int jresult ;
74102   int result;
74103
74104   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74105   jresult = (int)result;
74106   return jresult;
74107 }
74108
74109
74110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74111   int jresult ;
74112   int result;
74113
74114   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74115   jresult = (int)result;
74116   return jresult;
74117 }
74118
74119
74120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74121   int jresult ;
74122   int result;
74123
74124   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74125   jresult = (int)result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74131   int jresult ;
74132   int result;
74133
74134   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74135   jresult = (int)result;
74136   return jresult;
74137 }
74138
74139
74140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74141   int jresult ;
74142   int result;
74143
74144   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74145   jresult = (int)result;
74146   return jresult;
74147 }
74148
74149
74150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74151   int jresult ;
74152   int result;
74153
74154   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74155   jresult = (int)result;
74156   return jresult;
74157 }
74158
74159
74160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74161   int jresult ;
74162   int result;
74163
74164   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74165   jresult = (int)result;
74166   return jresult;
74167 }
74168
74169
74170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74171   int jresult ;
74172   int result;
74173
74174   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74175   jresult = (int)result;
74176   return jresult;
74177 }
74178
74179
74180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74181   int jresult ;
74182   int result;
74183
74184   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74185   jresult = (int)result;
74186   return jresult;
74187 }
74188
74189
74190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74191   int jresult ;
74192   int result;
74193
74194   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74195   jresult = (int)result;
74196   return jresult;
74197 }
74198
74199
74200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74201   int jresult ;
74202   int result;
74203
74204   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74205   jresult = (int)result;
74206   return jresult;
74207 }
74208
74209
74210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74211   int jresult ;
74212   int result;
74213
74214   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74215   jresult = (int)result;
74216   return jresult;
74217 }
74218
74219
74220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74221   int jresult ;
74222   int result;
74223
74224   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74225   jresult = (int)result;
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74231   int jresult ;
74232   int result;
74233
74234   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74235   jresult = (int)result;
74236   return jresult;
74237 }
74238
74239
74240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74241   int jresult ;
74242   int result;
74243
74244   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74245   jresult = (int)result;
74246   return jresult;
74247 }
74248
74249
74250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74251   int jresult ;
74252   int result;
74253
74254   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74255   jresult = (int)result;
74256   return jresult;
74257 }
74258
74259
74260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74261   int jresult ;
74262   int result;
74263
74264   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74265   jresult = (int)result;
74266   return jresult;
74267 }
74268
74269
74270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74271   int jresult ;
74272   int result;
74273
74274   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74275   jresult = (int)result;
74276   return jresult;
74277 }
74278
74279
74280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74281   int jresult ;
74282   int result;
74283
74284   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74285   jresult = (int)result;
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74291   void * jresult ;
74292   Dali::Toolkit::ScrollView::Property *result = 0 ;
74293
74294   {
74295     try {
74296       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
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_Property(void * jarg1) {
74317   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74318
74319   arg1 = (Dali::Toolkit::ScrollView::Property *)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_new_ScrollView__SWIG_0() {
74341   void * jresult ;
74342   Dali::Toolkit::ScrollView *result = 0 ;
74343
74344   {
74345     try {
74346       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
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 = (void *)result;
74362   return jresult;
74363 }
74364
74365
74366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74367   void * jresult ;
74368   Dali::Toolkit::ScrollView *arg1 = 0 ;
74369   Dali::Toolkit::ScrollView *result = 0 ;
74370
74371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74372   if (!arg1) {
74373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74374     return 0;
74375   }
74376   {
74377     try {
74378       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74379     } catch (std::out_of_range& e) {
74380       {
74381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74382       };
74383     } catch (std::exception& e) {
74384       {
74385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74386       };
74387     } catch (...) {
74388       {
74389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74390       };
74391     }
74392   }
74393   jresult = (void *)result;
74394   return jresult;
74395 }
74396
74397
74398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74399   void * jresult ;
74400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74401   Dali::Toolkit::ScrollView *arg2 = 0 ;
74402   Dali::Toolkit::ScrollView *result = 0 ;
74403
74404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74405   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74406   if (!arg2) {
74407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74408     return 0;
74409   }
74410   {
74411     try {
74412       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74413     } catch (std::out_of_range& e) {
74414       {
74415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74416       };
74417     } catch (std::exception& e) {
74418       {
74419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74420       };
74421     } catch (...) {
74422       {
74423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74424       };
74425     }
74426   }
74427   jresult = (void *)result;
74428   return jresult;
74429 }
74430
74431
74432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74434
74435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74436   {
74437     try {
74438       delete arg1;
74439     } catch (std::out_of_range& e) {
74440       {
74441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74442       };
74443     } catch (std::exception& e) {
74444       {
74445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (...) {
74448       {
74449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74450       };
74451     }
74452   }
74453 }
74454
74455
74456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74457   void * jresult ;
74458   Dali::Toolkit::ScrollView result;
74459
74460   {
74461     try {
74462       result = Dali::Toolkit::ScrollView::New();
74463     } catch (std::out_of_range& e) {
74464       {
74465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74466       };
74467     } catch (std::exception& e) {
74468       {
74469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74470       };
74471     } catch (...) {
74472       {
74473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74474       };
74475     }
74476   }
74477   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74478   return jresult;
74479 }
74480
74481
74482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74483   void * jresult ;
74484   Dali::BaseHandle arg1 ;
74485   Dali::BaseHandle *argp1 ;
74486   Dali::Toolkit::ScrollView result;
74487
74488   argp1 = (Dali::BaseHandle *)jarg1;
74489   if (!argp1) {
74490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74491     return 0;
74492   }
74493   arg1 = *argp1;
74494   {
74495     try {
74496       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74497     } catch (std::out_of_range& e) {
74498       {
74499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74500       };
74501     } catch (std::exception& e) {
74502       {
74503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74504       };
74505     } catch (...) {
74506       {
74507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74508       };
74509     }
74510   }
74511   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74512   return jresult;
74513 }
74514
74515
74516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74517   void * jresult ;
74518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74519   Dali::AlphaFunction result;
74520
74521   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74522   {
74523     try {
74524       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74532       };
74533     } catch (...) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74536       };
74537     }
74538   }
74539   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74540   return jresult;
74541 }
74542
74543
74544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74546   Dali::AlphaFunction arg2 ;
74547   Dali::AlphaFunction *argp2 ;
74548
74549   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74550   argp2 = (Dali::AlphaFunction *)jarg2;
74551   if (!argp2) {
74552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74553     return ;
74554   }
74555   arg2 = *argp2;
74556   {
74557     try {
74558       (arg1)->SetScrollSnapAlphaFunction(arg2);
74559     } catch (std::out_of_range& e) {
74560       {
74561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74562       };
74563     } catch (std::exception& e) {
74564       {
74565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74570       };
74571     }
74572   }
74573 }
74574
74575
74576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74577   void * jresult ;
74578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74579   Dali::AlphaFunction result;
74580
74581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74582   {
74583     try {
74584       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74585     } catch (std::out_of_range& e) {
74586       {
74587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74588       };
74589     } catch (std::exception& e) {
74590       {
74591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74592       };
74593     } catch (...) {
74594       {
74595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74596       };
74597     }
74598   }
74599   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74600   return jresult;
74601 }
74602
74603
74604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74606   Dali::AlphaFunction arg2 ;
74607   Dali::AlphaFunction *argp2 ;
74608
74609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74610   argp2 = (Dali::AlphaFunction *)jarg2;
74611   if (!argp2) {
74612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74613     return ;
74614   }
74615   arg2 = *argp2;
74616   {
74617     try {
74618       (arg1)->SetScrollFlickAlphaFunction(arg2);
74619     } catch (std::out_of_range& e) {
74620       {
74621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74622       };
74623     } catch (std::exception& e) {
74624       {
74625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74626       };
74627     } catch (...) {
74628       {
74629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74630       };
74631     }
74632   }
74633 }
74634
74635
74636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74637   float jresult ;
74638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74639   float result;
74640
74641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74642   {
74643     try {
74644       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74645     } catch (std::out_of_range& e) {
74646       {
74647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74648       };
74649     } catch (std::exception& e) {
74650       {
74651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74652       };
74653     } catch (...) {
74654       {
74655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74656       };
74657     }
74658   }
74659   jresult = result;
74660   return jresult;
74661 }
74662
74663
74664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74665   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74666   float arg2 ;
74667
74668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74669   arg2 = (float)jarg2;
74670   {
74671     try {
74672       (arg1)->SetScrollSnapDuration(arg2);
74673     } catch (std::out_of_range& e) {
74674       {
74675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74676       };
74677     } catch (std::exception& e) {
74678       {
74679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74680       };
74681     } catch (...) {
74682       {
74683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74684       };
74685     }
74686   }
74687 }
74688
74689
74690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74691   float jresult ;
74692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74693   float result;
74694
74695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74696   {
74697     try {
74698       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74699     } catch (std::out_of_range& e) {
74700       {
74701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74702       };
74703     } catch (std::exception& e) {
74704       {
74705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74706       };
74707     } catch (...) {
74708       {
74709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74710       };
74711     }
74712   }
74713   jresult = result;
74714   return jresult;
74715 }
74716
74717
74718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74720   float arg2 ;
74721
74722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74723   arg2 = (float)jarg2;
74724   {
74725     try {
74726       (arg1)->SetScrollFlickDuration(arg2);
74727     } catch (std::out_of_range& e) {
74728       {
74729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74730       };
74731     } catch (std::exception& e) {
74732       {
74733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74734       };
74735     } catch (...) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74738       };
74739     }
74740   }
74741 }
74742
74743
74744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74745   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74746   Dali::Toolkit::RulerPtr arg2 ;
74747   Dali::Toolkit::RulerPtr *argp2 ;
74748
74749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74750   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74751   if (!argp2) {
74752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74753     return ;
74754   }
74755   arg2 = *argp2;
74756   {
74757     try {
74758       (arg1)->SetRulerX(arg2);
74759     } catch (std::out_of_range& e) {
74760       {
74761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74762       };
74763     } catch (std::exception& e) {
74764       {
74765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74766       };
74767     } catch (...) {
74768       {
74769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74770       };
74771     }
74772   }
74773 }
74774
74775
74776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74778   Dali::Toolkit::RulerPtr arg2 ;
74779   Dali::Toolkit::RulerPtr *argp2 ;
74780
74781   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74782   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74783   if (!argp2) {
74784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74785     return ;
74786   }
74787   arg2 = *argp2;
74788   {
74789     try {
74790       (arg1)->SetRulerY(arg2);
74791     } catch (std::out_of_range& e) {
74792       {
74793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74794       };
74795     } catch (std::exception& e) {
74796       {
74797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74798       };
74799     } catch (...) {
74800       {
74801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74802       };
74803     }
74804   }
74805 }
74806
74807
74808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74810   bool arg2 ;
74811
74812   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74813   arg2 = jarg2 ? true : false;
74814   {
74815     try {
74816       (arg1)->SetScrollSensitive(arg2);
74817     } catch (std::out_of_range& e) {
74818       {
74819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74820       };
74821     } catch (std::exception& e) {
74822       {
74823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74824       };
74825     } catch (...) {
74826       {
74827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74828       };
74829     }
74830   }
74831 }
74832
74833
74834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74835   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74836   float arg2 ;
74837   float arg3 ;
74838
74839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74840   arg2 = (float)jarg2;
74841   arg3 = (float)jarg3;
74842   {
74843     try {
74844       (arg1)->SetMaxOvershoot(arg2,arg3);
74845     } catch (std::out_of_range& e) {
74846       {
74847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74848       };
74849     } catch (std::exception& e) {
74850       {
74851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74852       };
74853     } catch (...) {
74854       {
74855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74856       };
74857     }
74858   }
74859 }
74860
74861
74862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74864   Dali::AlphaFunction arg2 ;
74865   Dali::AlphaFunction *argp2 ;
74866
74867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74868   argp2 = (Dali::AlphaFunction *)jarg2;
74869   if (!argp2) {
74870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74871     return ;
74872   }
74873   arg2 = *argp2;
74874   {
74875     try {
74876       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74877     } catch (std::out_of_range& e) {
74878       {
74879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74880       };
74881     } catch (std::exception& e) {
74882       {
74883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74884       };
74885     } catch (...) {
74886       {
74887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74888       };
74889     }
74890   }
74891 }
74892
74893
74894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74896   float arg2 ;
74897
74898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74899   arg2 = (float)jarg2;
74900   {
74901     try {
74902       (arg1)->SetSnapOvershootDuration(arg2);
74903     } catch (std::out_of_range& e) {
74904       {
74905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74906       };
74907     } catch (std::exception& e) {
74908       {
74909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74910       };
74911     } catch (...) {
74912       {
74913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74914       };
74915     }
74916   }
74917 }
74918
74919
74920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74921   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74922   bool arg2 ;
74923
74924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74925   arg2 = jarg2 ? true : false;
74926   {
74927     try {
74928       (arg1)->SetActorAutoSnap(arg2);
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74936       };
74937     } catch (...) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74940       };
74941     }
74942   }
74943 }
74944
74945
74946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74948   bool arg2 ;
74949
74950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74951   arg2 = jarg2 ? true : false;
74952   {
74953     try {
74954       (arg1)->SetWrapMode(arg2);
74955     } catch (std::out_of_range& e) {
74956       {
74957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (std::exception& e) {
74960       {
74961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74962       };
74963     } catch (...) {
74964       {
74965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74966       };
74967     }
74968   }
74969 }
74970
74971
74972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74973   int jresult ;
74974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74975   int result;
74976
74977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74978   {
74979     try {
74980       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74981     } catch (std::out_of_range& e) {
74982       {
74983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (std::exception& e) {
74986       {
74987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (...) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74992       };
74993     }
74994   }
74995   jresult = result;
74996   return jresult;
74997 }
74998
74999
75000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75002   int arg2 ;
75003
75004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75005   arg2 = (int)jarg2;
75006   {
75007     try {
75008       (arg1)->SetScrollUpdateDistance(arg2);
75009     } catch (std::out_of_range& e) {
75010       {
75011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75012       };
75013     } catch (std::exception& e) {
75014       {
75015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75016       };
75017     } catch (...) {
75018       {
75019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75020       };
75021     }
75022   }
75023 }
75024
75025
75026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75027   unsigned int jresult ;
75028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75029   bool result;
75030
75031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75032   {
75033     try {
75034       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75035     } catch (std::out_of_range& e) {
75036       {
75037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75038       };
75039     } catch (std::exception& e) {
75040       {
75041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75042       };
75043     } catch (...) {
75044       {
75045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75046       };
75047     }
75048   }
75049   jresult = result;
75050   return jresult;
75051 }
75052
75053
75054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75056   bool arg2 ;
75057
75058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75059   arg2 = jarg2 ? true : false;
75060   {
75061     try {
75062       (arg1)->SetAxisAutoLock(arg2);
75063     } catch (std::out_of_range& e) {
75064       {
75065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75066       };
75067     } catch (std::exception& e) {
75068       {
75069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75070       };
75071     } catch (...) {
75072       {
75073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75074       };
75075     }
75076   }
75077 }
75078
75079
75080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75081   float jresult ;
75082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75083   float result;
75084
75085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75086   {
75087     try {
75088       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75089     } catch (std::out_of_range& e) {
75090       {
75091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75092       };
75093     } catch (std::exception& e) {
75094       {
75095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75096       };
75097     } catch (...) {
75098       {
75099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75100       };
75101     }
75102   }
75103   jresult = result;
75104   return jresult;
75105 }
75106
75107
75108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75110   float arg2 ;
75111
75112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75113   arg2 = (float)jarg2;
75114   {
75115     try {
75116       (arg1)->SetAxisAutoLockGradient(arg2);
75117     } catch (std::out_of_range& e) {
75118       {
75119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75120       };
75121     } catch (std::exception& e) {
75122       {
75123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75124       };
75125     } catch (...) {
75126       {
75127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75128       };
75129     }
75130   }
75131 }
75132
75133
75134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75135   float jresult ;
75136   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75137   float result;
75138
75139   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75140   {
75141     try {
75142       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75143     } catch (std::out_of_range& e) {
75144       {
75145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75146       };
75147     } catch (std::exception& e) {
75148       {
75149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75150       };
75151     } catch (...) {
75152       {
75153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75154       };
75155     }
75156   }
75157   jresult = result;
75158   return jresult;
75159 }
75160
75161
75162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75164   float arg2 ;
75165
75166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75167   arg2 = (float)jarg2;
75168   {
75169     try {
75170       (arg1)->SetFrictionCoefficient(arg2);
75171     } catch (std::out_of_range& e) {
75172       {
75173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (std::exception& e) {
75176       {
75177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (...) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75182       };
75183     }
75184   }
75185 }
75186
75187
75188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75189   float jresult ;
75190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75191   float result;
75192
75193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75194   {
75195     try {
75196       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75197     } catch (std::out_of_range& e) {
75198       {
75199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75200       };
75201     } catch (std::exception& e) {
75202       {
75203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75204       };
75205     } catch (...) {
75206       {
75207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75208       };
75209     }
75210   }
75211   jresult = result;
75212   return jresult;
75213 }
75214
75215
75216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75218   float arg2 ;
75219
75220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75221   arg2 = (float)jarg2;
75222   {
75223     try {
75224       (arg1)->SetFlickSpeedCoefficient(arg2);
75225     } catch (std::out_of_range& e) {
75226       {
75227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75228       };
75229     } catch (std::exception& e) {
75230       {
75231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75232       };
75233     } catch (...) {
75234       {
75235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75236       };
75237     }
75238   }
75239 }
75240
75241
75242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75243   void * jresult ;
75244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75245   Dali::Vector2 result;
75246
75247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75248   {
75249     try {
75250       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75251     } catch (std::out_of_range& e) {
75252       {
75253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (std::exception& e) {
75256       {
75257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75262       };
75263     }
75264   }
75265   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75266   return jresult;
75267 }
75268
75269
75270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75272   Dali::Vector2 *arg2 = 0 ;
75273
75274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75275   arg2 = (Dali::Vector2 *)jarg2;
75276   if (!arg2) {
75277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75278     return ;
75279   }
75280   {
75281     try {
75282       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75290       };
75291     } catch (...) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75294       };
75295     }
75296   }
75297 }
75298
75299
75300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75301   float jresult ;
75302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75303   float result;
75304
75305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75306   {
75307     try {
75308       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75309     } catch (std::out_of_range& e) {
75310       {
75311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75312       };
75313     } catch (std::exception& e) {
75314       {
75315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75316       };
75317     } catch (...) {
75318       {
75319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75320       };
75321     }
75322   }
75323   jresult = result;
75324   return jresult;
75325 }
75326
75327
75328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75330   float arg2 ;
75331
75332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75333   arg2 = (float)jarg2;
75334   {
75335     try {
75336       (arg1)->SetMinimumSpeedForFlick(arg2);
75337     } catch (std::out_of_range& e) {
75338       {
75339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75340       };
75341     } catch (std::exception& e) {
75342       {
75343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75344       };
75345     } catch (...) {
75346       {
75347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75348       };
75349     }
75350   }
75351 }
75352
75353
75354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75355   float jresult ;
75356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75357   float result;
75358
75359   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75360   {
75361     try {
75362       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75363     } catch (std::out_of_range& e) {
75364       {
75365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75366       };
75367     } catch (std::exception& e) {
75368       {
75369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75370       };
75371     } catch (...) {
75372       {
75373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75374       };
75375     }
75376   }
75377   jresult = result;
75378   return jresult;
75379 }
75380
75381
75382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75384   float arg2 ;
75385
75386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75387   arg2 = (float)jarg2;
75388   {
75389     try {
75390       (arg1)->SetMaxFlickSpeed(arg2);
75391     } catch (std::out_of_range& e) {
75392       {
75393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75394       };
75395     } catch (std::exception& e) {
75396       {
75397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75398       };
75399     } catch (...) {
75400       {
75401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75402       };
75403     }
75404   }
75405 }
75406
75407
75408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75409   void * jresult ;
75410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75411   Dali::Vector2 result;
75412
75413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75414   {
75415     try {
75416       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75417     } catch (std::out_of_range& e) {
75418       {
75419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75420       };
75421     } catch (std::exception& e) {
75422       {
75423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75424       };
75425     } catch (...) {
75426       {
75427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75428       };
75429     }
75430   }
75431   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75432   return jresult;
75433 }
75434
75435
75436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75437   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75438   Dali::Vector2 arg2 ;
75439   Dali::Vector2 *argp2 ;
75440
75441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75442   argp2 = (Dali::Vector2 *)jarg2;
75443   if (!argp2) {
75444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75445     return ;
75446   }
75447   arg2 = *argp2;
75448   {
75449     try {
75450       (arg1)->SetWheelScrollDistanceStep(arg2);
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75462       };
75463     }
75464   }
75465 }
75466
75467
75468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75469   void * jresult ;
75470   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75471   Dali::Vector2 result;
75472
75473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75474   {
75475     try {
75476       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75477     } catch (std::out_of_range& e) {
75478       {
75479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75480       };
75481     } catch (std::exception& e) {
75482       {
75483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75484       };
75485     } catch (...) {
75486       {
75487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75488       };
75489     }
75490   }
75491   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75492   return jresult;
75493 }
75494
75495
75496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75497   unsigned int jresult ;
75498   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75499   unsigned int result;
75500
75501   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75502   {
75503     try {
75504       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75505     } catch (std::out_of_range& e) {
75506       {
75507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75508       };
75509     } catch (std::exception& e) {
75510       {
75511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75512       };
75513     } catch (...) {
75514       {
75515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75516       };
75517     }
75518   }
75519   jresult = result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75526   Dali::Vector2 *arg2 = 0 ;
75527
75528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75529   arg2 = (Dali::Vector2 *)jarg2;
75530   if (!arg2) {
75531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75532     return ;
75533   }
75534   {
75535     try {
75536       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75537     } catch (std::out_of_range& e) {
75538       {
75539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75540       };
75541     } catch (std::exception& e) {
75542       {
75543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75544       };
75545     } catch (...) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75548       };
75549     }
75550   }
75551 }
75552
75553
75554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75555   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75556   Dali::Vector2 *arg2 = 0 ;
75557   float arg3 ;
75558
75559   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75560   arg2 = (Dali::Vector2 *)jarg2;
75561   if (!arg2) {
75562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75563     return ;
75564   }
75565   arg3 = (float)jarg3;
75566   {
75567     try {
75568       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75569     } catch (std::out_of_range& e) {
75570       {
75571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75572       };
75573     } catch (std::exception& e) {
75574       {
75575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75576       };
75577     } catch (...) {
75578       {
75579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75580       };
75581     }
75582   }
75583 }
75584
75585
75586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75587   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75588   Dali::Vector2 *arg2 = 0 ;
75589   float arg3 ;
75590   Dali::AlphaFunction arg4 ;
75591   Dali::AlphaFunction *argp4 ;
75592
75593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75594   arg2 = (Dali::Vector2 *)jarg2;
75595   if (!arg2) {
75596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75597     return ;
75598   }
75599   arg3 = (float)jarg3;
75600   argp4 = (Dali::AlphaFunction *)jarg4;
75601   if (!argp4) {
75602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75603     return ;
75604   }
75605   arg4 = *argp4;
75606   {
75607     try {
75608       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75609     } catch (std::out_of_range& e) {
75610       {
75611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75612       };
75613     } catch (std::exception& e) {
75614       {
75615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75616       };
75617     } catch (...) {
75618       {
75619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75620       };
75621     }
75622   }
75623 }
75624
75625
75626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75628   Dali::Vector2 *arg2 = 0 ;
75629   float arg3 ;
75630   Dali::Toolkit::DirectionBias arg4 ;
75631   Dali::Toolkit::DirectionBias arg5 ;
75632
75633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75634   arg2 = (Dali::Vector2 *)jarg2;
75635   if (!arg2) {
75636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75637     return ;
75638   }
75639   arg3 = (float)jarg3;
75640   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75641   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75642   {
75643     try {
75644       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75645     } catch (std::out_of_range& e) {
75646       {
75647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75648       };
75649     } catch (std::exception& e) {
75650       {
75651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75652       };
75653     } catch (...) {
75654       {
75655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75656       };
75657     }
75658   }
75659 }
75660
75661
75662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75663   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75664   Dali::Vector2 *arg2 = 0 ;
75665   float arg3 ;
75666   Dali::AlphaFunction arg4 ;
75667   Dali::Toolkit::DirectionBias arg5 ;
75668   Dali::Toolkit::DirectionBias arg6 ;
75669   Dali::AlphaFunction *argp4 ;
75670
75671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75672   arg2 = (Dali::Vector2 *)jarg2;
75673   if (!arg2) {
75674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75675     return ;
75676   }
75677   arg3 = (float)jarg3;
75678   argp4 = (Dali::AlphaFunction *)jarg4;
75679   if (!argp4) {
75680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75681     return ;
75682   }
75683   arg4 = *argp4;
75684   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75685   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75686   {
75687     try {
75688       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75689     } catch (std::out_of_range& e) {
75690       {
75691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75692       };
75693     } catch (std::exception& e) {
75694       {
75695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75700       };
75701     }
75702   }
75703 }
75704
75705
75706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75708   unsigned int arg2 ;
75709
75710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75711   arg2 = (unsigned int)jarg2;
75712   {
75713     try {
75714       (arg1)->ScrollTo(arg2);
75715     } catch (std::out_of_range& e) {
75716       {
75717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75718       };
75719     } catch (std::exception& e) {
75720       {
75721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75722       };
75723     } catch (...) {
75724       {
75725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75726       };
75727     }
75728   }
75729 }
75730
75731
75732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75734   unsigned int arg2 ;
75735   float arg3 ;
75736
75737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75738   arg2 = (unsigned int)jarg2;
75739   arg3 = (float)jarg3;
75740   {
75741     try {
75742       (arg1)->ScrollTo(arg2,arg3);
75743     } catch (std::out_of_range& e) {
75744       {
75745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75746       };
75747     } catch (std::exception& e) {
75748       {
75749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75750       };
75751     } catch (...) {
75752       {
75753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75754       };
75755     }
75756   }
75757 }
75758
75759
75760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75761   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75762   unsigned int arg2 ;
75763   float arg3 ;
75764   Dali::Toolkit::DirectionBias arg4 ;
75765
75766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75767   arg2 = (unsigned int)jarg2;
75768   arg3 = (float)jarg3;
75769   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75770   {
75771     try {
75772       (arg1)->ScrollTo(arg2,arg3,arg4);
75773     } catch (std::out_of_range& e) {
75774       {
75775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75776       };
75777     } catch (std::exception& e) {
75778       {
75779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75780       };
75781     } catch (...) {
75782       {
75783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75784       };
75785     }
75786   }
75787 }
75788
75789
75790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75792   Dali::Actor *arg2 = 0 ;
75793
75794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75795   arg2 = (Dali::Actor *)jarg2;
75796   if (!arg2) {
75797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75798     return ;
75799   }
75800   {
75801     try {
75802       (arg1)->ScrollTo(*arg2);
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_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75822   Dali::Actor *arg2 = 0 ;
75823   float arg3 ;
75824
75825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75826   arg2 = (Dali::Actor *)jarg2;
75827   if (!arg2) {
75828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75829     return ;
75830   }
75831   arg3 = (float)jarg3;
75832   {
75833     try {
75834       (arg1)->ScrollTo(*arg2,arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75853   unsigned int jresult ;
75854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75855   bool result;
75856
75857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75858   {
75859     try {
75860       result = (bool)(arg1)->ScrollToSnapPoint();
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75868       };
75869     } catch (...) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75872       };
75873     }
75874   }
75875   jresult = result;
75876   return jresult;
75877 }
75878
75879
75880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75882   Dali::Constraint arg2 ;
75883   Dali::Constraint *argp2 ;
75884
75885   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75886   argp2 = (Dali::Constraint *)jarg2;
75887   if (!argp2) {
75888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75889     return ;
75890   }
75891   arg2 = *argp2;
75892   {
75893     try {
75894       (arg1)->ApplyConstraintToChildren(arg2);
75895     } catch (std::out_of_range& e) {
75896       {
75897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75898       };
75899     } catch (std::exception& e) {
75900       {
75901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75902       };
75903     } catch (...) {
75904       {
75905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75906       };
75907     }
75908   }
75909 }
75910
75911
75912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75913   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75914
75915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75916   {
75917     try {
75918       (arg1)->RemoveConstraintsFromChildren();
75919     } catch (std::out_of_range& e) {
75920       {
75921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75922       };
75923     } catch (std::exception& e) {
75924       {
75925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75926       };
75927     } catch (...) {
75928       {
75929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75930       };
75931     }
75932   }
75933 }
75934
75935
75936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75938   Dali::Toolkit::ScrollViewEffect arg2 ;
75939   Dali::Toolkit::ScrollViewEffect *argp2 ;
75940
75941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75942   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75943   if (!argp2) {
75944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75945     return ;
75946   }
75947   arg2 = *argp2;
75948   {
75949     try {
75950       (arg1)->ApplyEffect(arg2);
75951     } catch (std::out_of_range& e) {
75952       {
75953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75954       };
75955     } catch (std::exception& e) {
75956       {
75957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75958       };
75959     } catch (...) {
75960       {
75961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75962       };
75963     }
75964   }
75965 }
75966
75967
75968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75969   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75970   Dali::Toolkit::ScrollViewEffect arg2 ;
75971   Dali::Toolkit::ScrollViewEffect *argp2 ;
75972
75973   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75974   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75975   if (!argp2) {
75976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75977     return ;
75978   }
75979   arg2 = *argp2;
75980   {
75981     try {
75982       (arg1)->RemoveEffect(arg2);
75983     } catch (std::out_of_range& e) {
75984       {
75985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75986       };
75987     } catch (std::exception& e) {
75988       {
75989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75990       };
75991     } catch (...) {
75992       {
75993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75994       };
75995     }
75996   }
75997 }
75998
75999
76000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76002
76003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76004   {
76005     try {
76006       (arg1)->RemoveAllEffects();
76007     } catch (std::out_of_range& e) {
76008       {
76009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76010       };
76011     } catch (std::exception& e) {
76012       {
76013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76014       };
76015     } catch (...) {
76016       {
76017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76018       };
76019     }
76020   }
76021 }
76022
76023
76024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76026   Dali::Actor arg2 ;
76027   Dali::Actor *argp2 ;
76028
76029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76030   argp2 = (Dali::Actor *)jarg2;
76031   if (!argp2) {
76032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76033     return ;
76034   }
76035   arg2 = *argp2;
76036   {
76037     try {
76038       (arg1)->BindActor(arg2);
76039     } catch (std::out_of_range& e) {
76040       {
76041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76042       };
76043     } catch (std::exception& e) {
76044       {
76045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76046       };
76047     } catch (...) {
76048       {
76049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76050       };
76051     }
76052   }
76053 }
76054
76055
76056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76058   Dali::Actor arg2 ;
76059   Dali::Actor *argp2 ;
76060
76061   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76062   argp2 = (Dali::Actor *)jarg2;
76063   if (!argp2) {
76064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76065     return ;
76066   }
76067   arg2 = *argp2;
76068   {
76069     try {
76070       (arg1)->UnbindActor(arg2);
76071     } catch (std::out_of_range& e) {
76072       {
76073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76074       };
76075     } catch (std::exception& e) {
76076       {
76077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76078       };
76079     } catch (...) {
76080       {
76081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76082       };
76083     }
76084   }
76085 }
76086
76087
76088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76090   Dali::Radian arg2 ;
76091   Dali::Radian arg3 ;
76092   Dali::Radian *argp2 ;
76093   Dali::Radian *argp3 ;
76094
76095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76096   argp2 = (Dali::Radian *)jarg2;
76097   if (!argp2) {
76098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76099     return ;
76100   }
76101   arg2 = *argp2;
76102   argp3 = (Dali::Radian *)jarg3;
76103   if (!argp3) {
76104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76105     return ;
76106   }
76107   arg3 = *argp3;
76108   {
76109     try {
76110       (arg1)->SetScrollingDirection(arg2,arg3);
76111     } catch (std::out_of_range& e) {
76112       {
76113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76114       };
76115     } catch (std::exception& e) {
76116       {
76117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76118       };
76119     } catch (...) {
76120       {
76121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76122       };
76123     }
76124   }
76125 }
76126
76127
76128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76130   Dali::Radian arg2 ;
76131   Dali::Radian *argp2 ;
76132
76133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76134   argp2 = (Dali::Radian *)jarg2;
76135   if (!argp2) {
76136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76137     return ;
76138   }
76139   arg2 = *argp2;
76140   {
76141     try {
76142       (arg1)->SetScrollingDirection(arg2);
76143     } catch (std::out_of_range& e) {
76144       {
76145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76146       };
76147     } catch (std::exception& e) {
76148       {
76149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76150       };
76151     } catch (...) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76154       };
76155     }
76156   }
76157 }
76158
76159
76160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76161   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76162   Dali::Radian arg2 ;
76163   Dali::Radian *argp2 ;
76164
76165   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76166   argp2 = (Dali::Radian *)jarg2;
76167   if (!argp2) {
76168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76169     return ;
76170   }
76171   arg2 = *argp2;
76172   {
76173     try {
76174       (arg1)->RemoveScrollingDirection(arg2);
76175     } catch (std::out_of_range& e) {
76176       {
76177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76178       };
76179     } catch (std::exception& e) {
76180       {
76181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76182       };
76183     } catch (...) {
76184       {
76185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76186       };
76187     }
76188   }
76189 }
76190
76191
76192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76193   void * jresult ;
76194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76195   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76196
76197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76198   {
76199     try {
76200       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76201     } catch (std::out_of_range& e) {
76202       {
76203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76204       };
76205     } catch (std::exception& e) {
76206       {
76207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76208       };
76209     } catch (...) {
76210       {
76211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76212       };
76213     }
76214   }
76215   jresult = (void *)result;
76216   return jresult;
76217 }
76218
76219
76220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76221   int jresult ;
76222   int result;
76223
76224   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76225   jresult = (int)result;
76226   return jresult;
76227 }
76228
76229
76230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76231   int jresult ;
76232   int result;
76233
76234   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76235   jresult = (int)result;
76236   return jresult;
76237 }
76238
76239
76240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76241   int jresult ;
76242   int result;
76243
76244   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76245   jresult = (int)result;
76246   return jresult;
76247 }
76248
76249
76250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76251   int jresult ;
76252   int result;
76253
76254   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76255   jresult = (int)result;
76256   return jresult;
76257 }
76258
76259
76260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76261   int jresult ;
76262   int result;
76263
76264   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76265   jresult = (int)result;
76266   return jresult;
76267 }
76268
76269
76270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76271   void * jresult ;
76272   Dali::Toolkit::TableView::Property *result = 0 ;
76273
76274   {
76275     try {
76276       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76277     } catch (std::out_of_range& e) {
76278       {
76279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76280       };
76281     } catch (std::exception& e) {
76282       {
76283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76284       };
76285     } catch (...) {
76286       {
76287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76288       };
76289     }
76290   }
76291   jresult = (void *)result;
76292   return jresult;
76293 }
76294
76295
76296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76297   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76298
76299   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76300   {
76301     try {
76302       delete arg1;
76303     } catch (std::out_of_range& e) {
76304       {
76305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76306       };
76307     } catch (std::exception& e) {
76308       {
76309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76310       };
76311     } catch (...) {
76312       {
76313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76314       };
76315     }
76316   }
76317 }
76318
76319
76320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76321   int jresult ;
76322   int result;
76323
76324   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76325   jresult = (int)result;
76326   return jresult;
76327 }
76328
76329
76330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76331   int jresult ;
76332   int result;
76333
76334   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76335   jresult = (int)result;
76336   return jresult;
76337 }
76338
76339
76340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76341   int jresult ;
76342   int result;
76343
76344   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76345   jresult = (int)result;
76346   return jresult;
76347 }
76348
76349
76350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76351   int jresult ;
76352   int result;
76353
76354   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76355   jresult = (int)result;
76356   return jresult;
76357 }
76358
76359
76360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76361   int jresult ;
76362   int result;
76363
76364   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76365   jresult = (int)result;
76366   return jresult;
76367 }
76368
76369
76370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76371   void * jresult ;
76372   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76373
76374   {
76375     try {
76376       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76377     } catch (std::out_of_range& e) {
76378       {
76379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76380       };
76381     } catch (std::exception& e) {
76382       {
76383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (...) {
76386       {
76387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76388       };
76389     }
76390   }
76391   jresult = (void *)result;
76392   return jresult;
76393 }
76394
76395
76396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76397   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76398
76399   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76400   {
76401     try {
76402       delete arg1;
76403     } catch (std::out_of_range& e) {
76404       {
76405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76406       };
76407     } catch (std::exception& e) {
76408       {
76409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76410       };
76411     } catch (...) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76414       };
76415     }
76416   }
76417 }
76418
76419
76420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76421   void * jresult ;
76422   unsigned int arg1 ;
76423   unsigned int arg2 ;
76424   unsigned int arg3 ;
76425   unsigned int arg4 ;
76426   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76427
76428   arg1 = (unsigned int)jarg1;
76429   arg2 = (unsigned int)jarg2;
76430   arg3 = (unsigned int)jarg3;
76431   arg4 = (unsigned int)jarg4;
76432   {
76433     try {
76434       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
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_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76455   void * jresult ;
76456   unsigned int arg1 ;
76457   unsigned int arg2 ;
76458   unsigned int arg3 ;
76459   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76460
76461   arg1 = (unsigned int)jarg1;
76462   arg2 = (unsigned int)jarg2;
76463   arg3 = (unsigned int)jarg3;
76464   {
76465     try {
76466       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76467     } catch (std::out_of_range& e) {
76468       {
76469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76470       };
76471     } catch (std::exception& e) {
76472       {
76473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76474       };
76475     } catch (...) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76478       };
76479     }
76480   }
76481   jresult = (void *)result;
76482   return jresult;
76483 }
76484
76485
76486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76487   void * jresult ;
76488   unsigned int arg1 ;
76489   unsigned int arg2 ;
76490   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76491
76492   arg1 = (unsigned int)jarg1;
76493   arg2 = (unsigned int)jarg2;
76494   {
76495     try {
76496       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76497     } catch (std::out_of_range& e) {
76498       {
76499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76500       };
76501     } catch (std::exception& e) {
76502       {
76503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76504       };
76505     } catch (...) {
76506       {
76507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76508       };
76509     }
76510   }
76511   jresult = (void *)result;
76512   return jresult;
76513 }
76514
76515
76516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76517   void * jresult ;
76518   unsigned int arg1 ;
76519   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76520
76521   arg1 = (unsigned int)jarg1;
76522   {
76523     try {
76524       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76525     } catch (std::out_of_range& e) {
76526       {
76527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76528       };
76529     } catch (std::exception& e) {
76530       {
76531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76532       };
76533     } catch (...) {
76534       {
76535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76536       };
76537     }
76538   }
76539   jresult = (void *)result;
76540   return jresult;
76541 }
76542
76543
76544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76545   void * jresult ;
76546   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76547
76548   {
76549     try {
76550       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76551     } catch (std::out_of_range& e) {
76552       {
76553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (std::exception& e) {
76556       {
76557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76562       };
76563     }
76564   }
76565   jresult = (void *)result;
76566   return jresult;
76567 }
76568
76569
76570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76571   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76572   unsigned int arg2 ;
76573
76574   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76575   arg2 = (unsigned int)jarg2;
76576   if (arg1) (arg1)->rowIndex = arg2;
76577 }
76578
76579
76580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76581   unsigned int jresult ;
76582   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76583   unsigned int result;
76584
76585   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76586   result = (unsigned int) ((arg1)->rowIndex);
76587   jresult = result;
76588   return jresult;
76589 }
76590
76591
76592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76593   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76594   unsigned int arg2 ;
76595
76596   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76597   arg2 = (unsigned int)jarg2;
76598   if (arg1) (arg1)->columnIndex = arg2;
76599 }
76600
76601
76602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76603   unsigned int jresult ;
76604   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76605   unsigned int result;
76606
76607   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76608   result = (unsigned int) ((arg1)->columnIndex);
76609   jresult = result;
76610   return jresult;
76611 }
76612
76613
76614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76615   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76616   unsigned int arg2 ;
76617
76618   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76619   arg2 = (unsigned int)jarg2;
76620   if (arg1) (arg1)->rowSpan = arg2;
76621 }
76622
76623
76624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76625   unsigned int jresult ;
76626   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76627   unsigned int result;
76628
76629   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76630   result = (unsigned int) ((arg1)->rowSpan);
76631   jresult = result;
76632   return jresult;
76633 }
76634
76635
76636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76637   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76638   unsigned int arg2 ;
76639
76640   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76641   arg2 = (unsigned int)jarg2;
76642   if (arg1) (arg1)->columnSpan = arg2;
76643 }
76644
76645
76646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76647   unsigned int jresult ;
76648   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76649   unsigned int result;
76650
76651   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76652   result = (unsigned int) ((arg1)->columnSpan);
76653   jresult = result;
76654   return jresult;
76655 }
76656
76657
76658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76659   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76660
76661   arg1 = (Dali::Toolkit::TableView::CellPosition *)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_new_TableView__SWIG_0() {
76683   void * jresult ;
76684   Dali::Toolkit::TableView *result = 0 ;
76685
76686   {
76687     try {
76688       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76689     } catch (std::out_of_range& e) {
76690       {
76691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76692       };
76693     } catch (std::exception& e) {
76694       {
76695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (...) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76700       };
76701     }
76702   }
76703   jresult = (void *)result;
76704   return jresult;
76705 }
76706
76707
76708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76709   void * jresult ;
76710   Dali::Toolkit::TableView *arg1 = 0 ;
76711   Dali::Toolkit::TableView *result = 0 ;
76712
76713   arg1 = (Dali::Toolkit::TableView *)jarg1;
76714   if (!arg1) {
76715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76716     return 0;
76717   }
76718   {
76719     try {
76720       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76721     } catch (std::out_of_range& e) {
76722       {
76723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76724       };
76725     } catch (std::exception& e) {
76726       {
76727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76728       };
76729     } catch (...) {
76730       {
76731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76732       };
76733     }
76734   }
76735   jresult = (void *)result;
76736   return jresult;
76737 }
76738
76739
76740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76741   void * jresult ;
76742   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76743   Dali::Toolkit::TableView *arg2 = 0 ;
76744   Dali::Toolkit::TableView *result = 0 ;
76745
76746   arg1 = (Dali::Toolkit::TableView *)jarg1;
76747   arg2 = (Dali::Toolkit::TableView *)jarg2;
76748   if (!arg2) {
76749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76750     return 0;
76751   }
76752   {
76753     try {
76754       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76755     } catch (std::out_of_range& e) {
76756       {
76757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76758       };
76759     } catch (std::exception& e) {
76760       {
76761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76762       };
76763     } catch (...) {
76764       {
76765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76766       };
76767     }
76768   }
76769   jresult = (void *)result;
76770   return jresult;
76771 }
76772
76773
76774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76776
76777   arg1 = (Dali::Toolkit::TableView *)jarg1;
76778   {
76779     try {
76780       delete arg1;
76781     } catch (std::out_of_range& e) {
76782       {
76783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76784       };
76785     } catch (std::exception& e) {
76786       {
76787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76788       };
76789     } catch (...) {
76790       {
76791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76792       };
76793     }
76794   }
76795 }
76796
76797
76798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76799   void * jresult ;
76800   unsigned int arg1 ;
76801   unsigned int arg2 ;
76802   Dali::Toolkit::TableView result;
76803
76804   arg1 = (unsigned int)jarg1;
76805   arg2 = (unsigned int)jarg2;
76806   {
76807     try {
76808       result = Dali::Toolkit::TableView::New(arg1,arg2);
76809     } catch (std::out_of_range& e) {
76810       {
76811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (std::exception& e) {
76814       {
76815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76816       };
76817     } catch (...) {
76818       {
76819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76820       };
76821     }
76822   }
76823   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76829   void * jresult ;
76830   Dali::BaseHandle arg1 ;
76831   Dali::BaseHandle *argp1 ;
76832   Dali::Toolkit::TableView result;
76833
76834   argp1 = (Dali::BaseHandle *)jarg1;
76835   if (!argp1) {
76836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76837     return 0;
76838   }
76839   arg1 = *argp1;
76840   {
76841     try {
76842       result = Dali::Toolkit::TableView::DownCast(arg1);
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::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76858   return jresult;
76859 }
76860
76861
76862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(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 ;
76867   Dali::Actor *argp2 ;
76868   Dali::Toolkit::TableView::CellPosition *argp3 ;
76869   bool result;
76870
76871   arg1 = (Dali::Toolkit::TableView *)jarg1;
76872   argp2 = (Dali::Actor *)jarg2;
76873   if (!argp2) {
76874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76875     return 0;
76876   }
76877   arg2 = *argp2;
76878   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76879   if (!argp3) {
76880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76881     return 0;
76882   }
76883   arg3 = *argp3;
76884   {
76885     try {
76886       result = (bool)(arg1)->AddChild(arg2,arg3);
76887     } catch (std::out_of_range& e) {
76888       {
76889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76890       };
76891     } catch (std::exception& e) {
76892       {
76893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76894       };
76895     } catch (...) {
76896       {
76897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76898       };
76899     }
76900   }
76901   jresult = result;
76902   return jresult;
76903 }
76904
76905
76906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76907   void * jresult ;
76908   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76909   Dali::Toolkit::TableView::CellPosition arg2 ;
76910   Dali::Toolkit::TableView::CellPosition *argp2 ;
76911   Dali::Actor result;
76912
76913   arg1 = (Dali::Toolkit::TableView *)jarg1;
76914   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76915   if (!argp2) {
76916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76917     return 0;
76918   }
76919   arg2 = *argp2;
76920   {
76921     try {
76922       result = (arg1)->GetChildAt(arg2);
76923     } catch (std::out_of_range& e) {
76924       {
76925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76926       };
76927     } catch (std::exception& e) {
76928       {
76929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76930       };
76931     } catch (...) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76934       };
76935     }
76936   }
76937   jresult = new Dali::Actor((const Dali::Actor &)result);
76938   return jresult;
76939 }
76940
76941
76942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76943   void * jresult ;
76944   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76945   Dali::Toolkit::TableView::CellPosition arg2 ;
76946   Dali::Toolkit::TableView::CellPosition *argp2 ;
76947   Dali::Actor result;
76948
76949   arg1 = (Dali::Toolkit::TableView *)jarg1;
76950   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76951   if (!argp2) {
76952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76953     return 0;
76954   }
76955   arg2 = *argp2;
76956   {
76957     try {
76958       result = (arg1)->RemoveChildAt(arg2);
76959     } catch (std::out_of_range& e) {
76960       {
76961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76962       };
76963     } catch (std::exception& e) {
76964       {
76965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76966       };
76967     } catch (...) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76970       };
76971     }
76972   }
76973   jresult = new Dali::Actor((const Dali::Actor &)result);
76974   return jresult;
76975 }
76976
76977
76978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76979   unsigned int jresult ;
76980   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76981   Dali::Actor arg2 ;
76982   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76983   Dali::Actor *argp2 ;
76984   bool result;
76985
76986   arg1 = (Dali::Toolkit::TableView *)jarg1;
76987   argp2 = (Dali::Actor *)jarg2;
76988   if (!argp2) {
76989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76990     return 0;
76991   }
76992   arg2 = *argp2;
76993   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76994   if (!arg3) {
76995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76996     return 0;
76997   }
76998   {
76999     try {
77000       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77001     } catch (std::out_of_range& e) {
77002       {
77003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77004       };
77005     } catch (std::exception& e) {
77006       {
77007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77008       };
77009     } catch (...) {
77010       {
77011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77012       };
77013     }
77014   }
77015   jresult = result;
77016   return jresult;
77017 }
77018
77019
77020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77021   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77022   unsigned int arg2 ;
77023
77024   arg1 = (Dali::Toolkit::TableView *)jarg1;
77025   arg2 = (unsigned int)jarg2;
77026   {
77027     try {
77028       (arg1)->InsertRow(arg2);
77029     } catch (std::out_of_range& e) {
77030       {
77031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77032       };
77033     } catch (std::exception& e) {
77034       {
77035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77036       };
77037     } catch (...) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77040       };
77041     }
77042   }
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77048   unsigned int arg2 ;
77049
77050   arg1 = (Dali::Toolkit::TableView *)jarg1;
77051   arg2 = (unsigned int)jarg2;
77052   {
77053     try {
77054       (arg1)->DeleteRow(arg2);
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_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77074   unsigned int arg2 ;
77075   std::vector< Dali::Actor > *arg3 = 0 ;
77076
77077   arg1 = (Dali::Toolkit::TableView *)jarg1;
77078   arg2 = (unsigned int)jarg2;
77079   arg3 = (std::vector< Dali::Actor > *)jarg3;
77080   if (!arg3) {
77081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77082     return ;
77083   }
77084   {
77085     try {
77086       (arg1)->DeleteRow(arg2,*arg3);
77087     } catch (std::out_of_range& e) {
77088       {
77089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77090       };
77091     } catch (std::exception& e) {
77092       {
77093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77098       };
77099     }
77100   }
77101 }
77102
77103
77104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77105   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77106   unsigned int arg2 ;
77107
77108   arg1 = (Dali::Toolkit::TableView *)jarg1;
77109   arg2 = (unsigned int)jarg2;
77110   {
77111     try {
77112       (arg1)->InsertColumn(arg2);
77113     } catch (std::out_of_range& e) {
77114       {
77115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77116       };
77117     } catch (std::exception& e) {
77118       {
77119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77120       };
77121     } catch (...) {
77122       {
77123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77124       };
77125     }
77126   }
77127 }
77128
77129
77130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77131   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77132   unsigned int arg2 ;
77133
77134   arg1 = (Dali::Toolkit::TableView *)jarg1;
77135   arg2 = (unsigned int)jarg2;
77136   {
77137     try {
77138       (arg1)->DeleteColumn(arg2);
77139     } catch (std::out_of_range& e) {
77140       {
77141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77142       };
77143     } catch (std::exception& e) {
77144       {
77145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77150       };
77151     }
77152   }
77153 }
77154
77155
77156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77158   unsigned int arg2 ;
77159   std::vector< Dali::Actor > *arg3 = 0 ;
77160
77161   arg1 = (Dali::Toolkit::TableView *)jarg1;
77162   arg2 = (unsigned int)jarg2;
77163   arg3 = (std::vector< Dali::Actor > *)jarg3;
77164   if (!arg3) {
77165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77166     return ;
77167   }
77168   {
77169     try {
77170       (arg1)->DeleteColumn(arg2,*arg3);
77171     } catch (std::out_of_range& e) {
77172       {
77173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77174       };
77175     } catch (std::exception& e) {
77176       {
77177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77178       };
77179     } catch (...) {
77180       {
77181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77182       };
77183     }
77184   }
77185 }
77186
77187
77188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77189   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77190   unsigned int arg2 ;
77191   unsigned int arg3 ;
77192
77193   arg1 = (Dali::Toolkit::TableView *)jarg1;
77194   arg2 = (unsigned int)jarg2;
77195   arg3 = (unsigned int)jarg3;
77196   {
77197     try {
77198       (arg1)->Resize(arg2,arg3);
77199     } catch (std::out_of_range& e) {
77200       {
77201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77202       };
77203     } catch (std::exception& e) {
77204       {
77205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (...) {
77208       {
77209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77210       };
77211     }
77212   }
77213 }
77214
77215
77216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77217   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77218   unsigned int arg2 ;
77219   unsigned int arg3 ;
77220   std::vector< Dali::Actor > *arg4 = 0 ;
77221
77222   arg1 = (Dali::Toolkit::TableView *)jarg1;
77223   arg2 = (unsigned int)jarg2;
77224   arg3 = (unsigned int)jarg3;
77225   arg4 = (std::vector< Dali::Actor > *)jarg4;
77226   if (!arg4) {
77227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77228     return ;
77229   }
77230   {
77231     try {
77232       (arg1)->Resize(arg2,arg3,*arg4);
77233     } catch (std::out_of_range& e) {
77234       {
77235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77236       };
77237     } catch (std::exception& e) {
77238       {
77239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77240       };
77241     } catch (...) {
77242       {
77243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77244       };
77245     }
77246   }
77247 }
77248
77249
77250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77251   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77252   Dali::Size arg2 ;
77253   Dali::Size *argp2 ;
77254
77255   arg1 = (Dali::Toolkit::TableView *)jarg1;
77256   argp2 = (Dali::Size *)jarg2;
77257   if (!argp2) {
77258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77259     return ;
77260   }
77261   arg2 = *argp2;
77262   {
77263     try {
77264       (arg1)->SetCellPadding(arg2);
77265     } catch (std::out_of_range& e) {
77266       {
77267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77268       };
77269     } catch (std::exception& e) {
77270       {
77271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77272       };
77273     } catch (...) {
77274       {
77275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77276       };
77277     }
77278   }
77279 }
77280
77281
77282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77283   void * jresult ;
77284   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77285   Dali::Size result;
77286
77287   arg1 = (Dali::Toolkit::TableView *)jarg1;
77288   {
77289     try {
77290       result = (arg1)->GetCellPadding();
77291     } catch (std::out_of_range& e) {
77292       {
77293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77294       };
77295     } catch (std::exception& e) {
77296       {
77297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77298       };
77299     } catch (...) {
77300       {
77301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77302       };
77303     }
77304   }
77305   jresult = new Dali::Size((const Dali::Size &)result);
77306   return jresult;
77307 }
77308
77309
77310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77311   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77312   unsigned int arg2 ;
77313
77314   arg1 = (Dali::Toolkit::TableView *)jarg1;
77315   arg2 = (unsigned int)jarg2;
77316   {
77317     try {
77318       (arg1)->SetFitHeight(arg2);
77319     } catch (std::out_of_range& e) {
77320       {
77321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77322       };
77323     } catch (std::exception& e) {
77324       {
77325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77326       };
77327     } catch (...) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77330       };
77331     }
77332   }
77333 }
77334
77335
77336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77337   unsigned int jresult ;
77338   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77339   unsigned int arg2 ;
77340   bool result;
77341
77342   arg1 = (Dali::Toolkit::TableView *)jarg1;
77343   arg2 = (unsigned int)jarg2;
77344   {
77345     try {
77346       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77347     } catch (std::out_of_range& e) {
77348       {
77349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (std::exception& e) {
77352       {
77353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77354       };
77355     } catch (...) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77358       };
77359     }
77360   }
77361   jresult = result;
77362   return jresult;
77363 }
77364
77365
77366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77367   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77368   unsigned int arg2 ;
77369
77370   arg1 = (Dali::Toolkit::TableView *)jarg1;
77371   arg2 = (unsigned int)jarg2;
77372   {
77373     try {
77374       (arg1)->SetFitWidth(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77393   unsigned int jresult ;
77394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77395   unsigned int arg2 ;
77396   bool result;
77397
77398   arg1 = (Dali::Toolkit::TableView *)jarg1;
77399   arg2 = (unsigned int)jarg2;
77400   {
77401     try {
77402       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(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_SetFixedHeight(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)->SetFixedHeight(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_GetFixedHeight(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)->GetFixedHeight(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_SetRelativeHeight(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)->SetRelativeHeight(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_GetRelativeHeight(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)->GetRelativeHeight(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 void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77539   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77540   unsigned int arg2 ;
77541   float arg3 ;
77542
77543   arg1 = (Dali::Toolkit::TableView *)jarg1;
77544   arg2 = (unsigned int)jarg2;
77545   arg3 = (float)jarg3;
77546   {
77547     try {
77548       (arg1)->SetFixedWidth(arg2,arg3);
77549     } catch (std::out_of_range& e) {
77550       {
77551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77552       };
77553     } catch (std::exception& e) {
77554       {
77555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77556       };
77557     } catch (...) {
77558       {
77559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77560       };
77561     }
77562   }
77563 }
77564
77565
77566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77567   float jresult ;
77568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77569   unsigned int arg2 ;
77570   float result;
77571
77572   arg1 = (Dali::Toolkit::TableView *)jarg1;
77573   arg2 = (unsigned int)jarg2;
77574   {
77575     try {
77576       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77577     } catch (std::out_of_range& e) {
77578       {
77579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77580       };
77581     } catch (std::exception& e) {
77582       {
77583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77584       };
77585     } catch (...) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77588       };
77589     }
77590   }
77591   jresult = result;
77592   return jresult;
77593 }
77594
77595
77596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77597   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77598   unsigned int arg2 ;
77599   float arg3 ;
77600
77601   arg1 = (Dali::Toolkit::TableView *)jarg1;
77602   arg2 = (unsigned int)jarg2;
77603   arg3 = (float)jarg3;
77604   {
77605     try {
77606       (arg1)->SetRelativeWidth(arg2,arg3);
77607     } catch (std::out_of_range& e) {
77608       {
77609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77610       };
77611     } catch (std::exception& e) {
77612       {
77613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77614       };
77615     } catch (...) {
77616       {
77617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77618       };
77619     }
77620   }
77621 }
77622
77623
77624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77625   float jresult ;
77626   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77627   unsigned int arg2 ;
77628   float result;
77629
77630   arg1 = (Dali::Toolkit::TableView *)jarg1;
77631   arg2 = (unsigned int)jarg2;
77632   {
77633     try {
77634       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77635     } catch (std::out_of_range& e) {
77636       {
77637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77638       };
77639     } catch (std::exception& e) {
77640       {
77641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77642       };
77643     } catch (...) {
77644       {
77645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77646       };
77647     }
77648   }
77649   jresult = result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77655   unsigned int jresult ;
77656   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77657   unsigned int result;
77658
77659   arg1 = (Dali::Toolkit::TableView *)jarg1;
77660   {
77661     try {
77662       result = (unsigned int)(arg1)->GetRows();
77663     } catch (std::out_of_range& e) {
77664       {
77665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77666       };
77667     } catch (std::exception& e) {
77668       {
77669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77670       };
77671     } catch (...) {
77672       {
77673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77674       };
77675     }
77676   }
77677   jresult = result;
77678   return jresult;
77679 }
77680
77681
77682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77683   unsigned int jresult ;
77684   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77685   unsigned int result;
77686
77687   arg1 = (Dali::Toolkit::TableView *)jarg1;
77688   {
77689     try {
77690       result = (unsigned int)(arg1)->GetColumns();
77691     } catch (std::out_of_range& e) {
77692       {
77693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77694       };
77695     } catch (std::exception& e) {
77696       {
77697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77698       };
77699     } catch (...) {
77700       {
77701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77702       };
77703     }
77704   }
77705   jresult = result;
77706   return jresult;
77707 }
77708
77709
77710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77712   Dali::Toolkit::TableView::CellPosition arg2 ;
77713   Dali::HorizontalAlignment::Type arg3 ;
77714   Dali::VerticalAlignment::Type arg4 ;
77715   Dali::Toolkit::TableView::CellPosition *argp2 ;
77716
77717   arg1 = (Dali::Toolkit::TableView *)jarg1;
77718   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77719   if (!argp2) {
77720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77721     return ;
77722   }
77723   arg2 = *argp2;
77724   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77725   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77726   {
77727     try {
77728       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77729     } catch (std::out_of_range& e) {
77730       {
77731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77732       };
77733     } catch (std::exception& e) {
77734       {
77735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77736       };
77737     } catch (...) {
77738       {
77739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77740       };
77741     }
77742   }
77743 }
77744
77745
77746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77747   unsigned int jresult ;
77748   unsigned int result;
77749
77750   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77751   jresult = result;
77752   return jresult;
77753 }
77754
77755
77756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77757   int jresult ;
77758   int result;
77759
77760   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77761   jresult = (int)result;
77762   return jresult;
77763 }
77764
77765
77766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77767   int jresult ;
77768   int result;
77769
77770   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77771   jresult = (int)result;
77772   return jresult;
77773 }
77774
77775
77776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77777   int jresult ;
77778   int result;
77779
77780   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77781   jresult = (int)result;
77782   return jresult;
77783 }
77784
77785
77786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77787   int jresult ;
77788   int result;
77789
77790   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77791   jresult = (int)result;
77792   return jresult;
77793 }
77794
77795
77796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77797   int jresult ;
77798   int result;
77799
77800   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77801   jresult = (int)result;
77802   return jresult;
77803 }
77804
77805
77806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77807   int jresult ;
77808   int result;
77809
77810   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77811   jresult = (int)result;
77812   return jresult;
77813 }
77814
77815
77816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77817   int jresult ;
77818   int result;
77819
77820   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77821   jresult = (int)result;
77822   return jresult;
77823 }
77824
77825
77826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77827   int jresult ;
77828   int result;
77829
77830   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77831   jresult = (int)result;
77832   return jresult;
77833 }
77834
77835
77836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77837   int jresult ;
77838   int result;
77839
77840   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77841   jresult = (int)result;
77842   return jresult;
77843 }
77844
77845
77846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77847   int jresult ;
77848   int result;
77849
77850   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77851   jresult = (int)result;
77852   return jresult;
77853 }
77854
77855
77856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77857   int jresult ;
77858   int result;
77859
77860   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77861   jresult = (int)result;
77862   return jresult;
77863 }
77864
77865
77866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77867   int jresult ;
77868   int result;
77869
77870   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77871   jresult = (int)result;
77872   return jresult;
77873 }
77874
77875
77876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77877   int jresult ;
77878   int result;
77879
77880   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77881   jresult = (int)result;
77882   return jresult;
77883 }
77884
77885
77886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77887   int jresult ;
77888   int result;
77889
77890   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77891   jresult = (int)result;
77892   return jresult;
77893 }
77894
77895
77896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77897   int jresult ;
77898   int result;
77899
77900   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77901   jresult = (int)result;
77902   return jresult;
77903 }
77904
77905
77906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77907   int jresult ;
77908   int result;
77909
77910   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77911   jresult = (int)result;
77912   return jresult;
77913 }
77914
77915
77916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77917   int jresult ;
77918   int result;
77919
77920   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77921   jresult = (int)result;
77922   return jresult;
77923 }
77924
77925
77926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77927   int jresult ;
77928   int result;
77929
77930   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77931   jresult = (int)result;
77932   return jresult;
77933 }
77934
77935
77936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77937   int jresult ;
77938   int result;
77939
77940   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77941   jresult = (int)result;
77942   return jresult;
77943 }
77944
77945
77946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77947   int jresult ;
77948   int result;
77949
77950   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77951   jresult = (int)result;
77952   return jresult;
77953 }
77954
77955
77956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77957   int jresult ;
77958   int result;
77959
77960   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77961   jresult = (int)result;
77962   return jresult;
77963 }
77964
77965
77966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77967   int jresult ;
77968   int result;
77969
77970   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77971   jresult = (int)result;
77972   return jresult;
77973 }
77974
77975
77976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77977   int jresult ;
77978   int result;
77979
77980   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77981   jresult = (int)result;
77982   return jresult;
77983 }
77984
77985
77986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77987   int jresult ;
77988   int result;
77989
77990   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77991   jresult = (int)result;
77992   return jresult;
77993 }
77994
77995
77996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77997   int jresult ;
77998   int result;
77999
78000   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
78001   jresult = (int)result;
78002   return jresult;
78003 }
78004
78005
78006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
78007   int jresult ;
78008   int result;
78009
78010   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
78011   jresult = (int)result;
78012   return jresult;
78013 }
78014
78015
78016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
78017   int jresult ;
78018   int result;
78019
78020   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
78021   jresult = (int)result;
78022   return jresult;
78023 }
78024
78025
78026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
78027   int jresult ;
78028   int result;
78029
78030   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
78031   jresult = (int)result;
78032   return jresult;
78033 }
78034
78035
78036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
78037   int jresult ;
78038   int result;
78039
78040   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
78041   jresult = (int)result;
78042   return jresult;
78043 }
78044
78045
78046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
78047   int jresult ;
78048   int result;
78049
78050   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
78051   jresult = (int)result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
78057   int jresult ;
78058   int result;
78059
78060   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
78061   jresult = (int)result;
78062   return jresult;
78063 }
78064
78065
78066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
78067   int jresult ;
78068   int result;
78069
78070   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
78071   jresult = (int)result;
78072   return jresult;
78073 }
78074
78075
78076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
78077   int jresult ;
78078   int result;
78079
78080   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
78081   jresult = (int)result;
78082   return jresult;
78083 }
78084
78085
78086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
78087   int jresult ;
78088   int result;
78089
78090   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
78091   jresult = (int)result;
78092   return jresult;
78093 }
78094
78095
78096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
78097   int jresult ;
78098   int result;
78099
78100   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
78101   jresult = (int)result;
78102   return jresult;
78103 }
78104
78105
78106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
78107   int jresult ;
78108   int result;
78109
78110   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
78111   jresult = (int)result;
78112   return jresult;
78113 }
78114
78115
78116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78117   int jresult ;
78118   int result;
78119
78120   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78121   jresult = (int)result;
78122   return jresult;
78123 }
78124
78125
78126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78127   int jresult ;
78128   int result;
78129
78130   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78131   jresult = (int)result;
78132   return jresult;
78133 }
78134
78135
78136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78137   int jresult ;
78138   int result;
78139
78140   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78141   jresult = (int)result;
78142   return jresult;
78143 }
78144
78145
78146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78147   int jresult ;
78148   int result;
78149
78150   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78151   jresult = (int)result;
78152   return jresult;
78153 }
78154
78155
78156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78157   void * jresult ;
78158   Dali::Toolkit::TextEditor::Property *result = 0 ;
78159
78160   {
78161     try {
78162       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78163     } catch (std::out_of_range& e) {
78164       {
78165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78166       };
78167     } catch (std::exception& e) {
78168       {
78169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78170       };
78171     } catch (...) {
78172       {
78173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78174       };
78175     }
78176   }
78177   jresult = (void *)result;
78178   return jresult;
78179 }
78180
78181
78182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78183   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78184
78185   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78186   {
78187     try {
78188       delete arg1;
78189     } catch (std::out_of_range& e) {
78190       {
78191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78192       };
78193     } catch (std::exception& e) {
78194       {
78195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78196       };
78197     } catch (...) {
78198       {
78199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78200       };
78201     }
78202   }
78203 }
78204
78205
78206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78207   void * jresult ;
78208   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78209
78210   {
78211     try {
78212       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78213     } catch (std::out_of_range& e) {
78214       {
78215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78216       };
78217     } catch (std::exception& e) {
78218       {
78219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78220       };
78221     } catch (...) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78224       };
78225     }
78226   }
78227   jresult = (void *)result;
78228   return jresult;
78229 }
78230
78231
78232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78233   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78234
78235   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78236   {
78237     try {
78238       delete arg1;
78239     } catch (std::out_of_range& e) {
78240       {
78241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78242       };
78243     } catch (std::exception& e) {
78244       {
78245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78246       };
78247     } catch (...) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78250       };
78251     }
78252   }
78253 }
78254
78255
78256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78257   void * jresult ;
78258   Dali::Toolkit::TextEditor result;
78259
78260   {
78261     try {
78262       result = Dali::Toolkit::TextEditor::New();
78263     } catch (std::out_of_range& e) {
78264       {
78265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78266       };
78267     } catch (std::exception& e) {
78268       {
78269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78270       };
78271     } catch (...) {
78272       {
78273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78274       };
78275     }
78276   }
78277   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78278   return jresult;
78279 }
78280
78281
78282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78283   void * jresult ;
78284   Dali::Toolkit::TextEditor *result = 0 ;
78285
78286   {
78287     try {
78288       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78289     } catch (std::out_of_range& e) {
78290       {
78291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78292       };
78293     } catch (std::exception& e) {
78294       {
78295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78296       };
78297     } catch (...) {
78298       {
78299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78300       };
78301     }
78302   }
78303   jresult = (void *)result;
78304   return jresult;
78305 }
78306
78307
78308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78309   void * jresult ;
78310   Dali::Toolkit::TextEditor *arg1 = 0 ;
78311   Dali::Toolkit::TextEditor *result = 0 ;
78312
78313   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78314   if (!arg1) {
78315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78316     return 0;
78317   }
78318   {
78319     try {
78320       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78321     } catch (std::out_of_range& e) {
78322       {
78323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (std::exception& e) {
78326       {
78327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78328       };
78329     } catch (...) {
78330       {
78331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78332       };
78333     }
78334   }
78335   jresult = (void *)result;
78336   return jresult;
78337 }
78338
78339
78340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78341   void * jresult ;
78342   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78343   Dali::Toolkit::TextEditor *arg2 = 0 ;
78344   Dali::Toolkit::TextEditor *result = 0 ;
78345
78346   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78347   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78348   if (!arg2) {
78349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78350     return 0;
78351   }
78352   {
78353     try {
78354       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78355     } catch (std::out_of_range& e) {
78356       {
78357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78358       };
78359     } catch (std::exception& e) {
78360       {
78361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78362       };
78363     } catch (...) {
78364       {
78365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78366       };
78367     }
78368   }
78369   jresult = (void *)result;
78370   return jresult;
78371 }
78372
78373
78374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78375   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78376
78377   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78378   {
78379     try {
78380       delete arg1;
78381     } catch (std::out_of_range& e) {
78382       {
78383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78384       };
78385     } catch (std::exception& e) {
78386       {
78387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78388       };
78389     } catch (...) {
78390       {
78391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78392       };
78393     }
78394   }
78395 }
78396
78397
78398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78399   void * jresult ;
78400   Dali::BaseHandle arg1 ;
78401   Dali::BaseHandle *argp1 ;
78402   Dali::Toolkit::TextEditor result;
78403
78404   argp1 = (Dali::BaseHandle *)jarg1;
78405   if (!argp1) {
78406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78407     return 0;
78408   }
78409   arg1 = *argp1;
78410   {
78411     try {
78412       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78413     } catch (std::out_of_range& e) {
78414       {
78415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78416       };
78417     } catch (std::exception& e) {
78418       {
78419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78420       };
78421     } catch (...) {
78422       {
78423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78424       };
78425     }
78426   }
78427   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78428   return jresult;
78429 }
78430
78431
78432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78433   void * jresult ;
78434   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78435   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78436
78437   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78438   {
78439     try {
78440       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78441     } catch (std::out_of_range& e) {
78442       {
78443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (std::exception& e) {
78446       {
78447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455   jresult = (void *)result;
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78461   void * jresult ;
78462   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78463   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78464
78465   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78466   {
78467     try {
78468       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (...) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78480       };
78481     }
78482   }
78483   jresult = (void *)result;
78484   return jresult;
78485 }
78486
78487
78488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78489   int jresult ;
78490   int result;
78491
78492   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78493   jresult = (int)result;
78494   return jresult;
78495 }
78496
78497
78498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78499   int jresult ;
78500   int result;
78501
78502   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78503   jresult = (int)result;
78504   return jresult;
78505 }
78506
78507
78508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78509   int jresult ;
78510   int result;
78511
78512   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78513   jresult = (int)result;
78514   return jresult;
78515 }
78516
78517
78518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78519   int jresult ;
78520   int result;
78521
78522   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78523   jresult = (int)result;
78524   return jresult;
78525 }
78526
78527
78528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78529   int jresult ;
78530   int result;
78531
78532   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78533   jresult = (int)result;
78534   return jresult;
78535 }
78536
78537
78538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78539   int jresult ;
78540   int result;
78541
78542   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78543   jresult = (int)result;
78544   return jresult;
78545 }
78546
78547
78548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78549   int jresult ;
78550   int result;
78551
78552   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78553   jresult = (int)result;
78554   return jresult;
78555 }
78556
78557
78558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78559   int jresult ;
78560   int result;
78561
78562   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78563   jresult = (int)result;
78564   return jresult;
78565 }
78566
78567
78568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78569   int jresult ;
78570   int result;
78571
78572   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78573   jresult = (int)result;
78574   return jresult;
78575 }
78576
78577
78578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78579   int jresult ;
78580   int result;
78581
78582   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78583   jresult = (int)result;
78584   return jresult;
78585 }
78586
78587
78588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78589   int jresult ;
78590   int result;
78591
78592   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78593   jresult = (int)result;
78594   return jresult;
78595 }
78596
78597
78598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78599   int jresult ;
78600   int result;
78601
78602   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78603   jresult = (int)result;
78604   return jresult;
78605 }
78606
78607
78608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78609   int jresult ;
78610   int result;
78611
78612   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78613   jresult = (int)result;
78614   return jresult;
78615 }
78616
78617
78618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78619   int jresult ;
78620   int result;
78621
78622   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78623   jresult = (int)result;
78624   return jresult;
78625 }
78626
78627
78628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78629   int jresult ;
78630   int result;
78631
78632   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78633   jresult = (int)result;
78634   return jresult;
78635 }
78636
78637
78638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78639   int jresult ;
78640   int result;
78641
78642   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78643   jresult = (int)result;
78644   return jresult;
78645 }
78646
78647
78648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78649   int jresult ;
78650   int result;
78651
78652   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78653   jresult = (int)result;
78654   return jresult;
78655 }
78656
78657
78658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78659   int jresult ;
78660   int result;
78661
78662   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78663   jresult = (int)result;
78664   return jresult;
78665 }
78666
78667
78668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78669   int jresult ;
78670   int result;
78671
78672   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78673   jresult = (int)result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78679   int jresult ;
78680   int result;
78681
78682   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78683   jresult = (int)result;
78684   return jresult;
78685 }
78686
78687
78688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78689   int jresult ;
78690   int result;
78691
78692   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78693   jresult = (int)result;
78694   return jresult;
78695 }
78696
78697
78698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78699   int jresult ;
78700   int result;
78701
78702   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78703   jresult = (int)result;
78704   return jresult;
78705 }
78706
78707
78708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78709   int jresult ;
78710   int result;
78711
78712   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78713   jresult = (int)result;
78714   return jresult;
78715 }
78716
78717
78718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78719   int jresult ;
78720   int result;
78721
78722   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78723   jresult = (int)result;
78724   return jresult;
78725 }
78726
78727
78728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78729   int jresult ;
78730   int result;
78731
78732   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78733   jresult = (int)result;
78734   return jresult;
78735 }
78736
78737
78738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78739   int jresult ;
78740   int result;
78741
78742   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78743   jresult = (int)result;
78744   return jresult;
78745 }
78746
78747
78748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78749   int jresult ;
78750   int result;
78751
78752   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78753   jresult = (int)result;
78754   return jresult;
78755 }
78756
78757
78758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78759   int jresult ;
78760   int result;
78761
78762   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78763   jresult = (int)result;
78764   return jresult;
78765 }
78766
78767
78768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78769   int jresult ;
78770   int result;
78771
78772   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78773   jresult = (int)result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78779   int jresult ;
78780   int result;
78781
78782   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78783   jresult = (int)result;
78784   return jresult;
78785 }
78786
78787
78788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78789   int jresult ;
78790   int result;
78791
78792   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78793   jresult = (int)result;
78794   return jresult;
78795 }
78796
78797
78798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78799   int jresult ;
78800   int result;
78801
78802   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78803   jresult = (int)result;
78804   return jresult;
78805 }
78806
78807
78808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78809   int jresult ;
78810   int result;
78811
78812   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78813   jresult = (int)result;
78814   return jresult;
78815 }
78816
78817
78818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78819   int jresult ;
78820   int result;
78821
78822   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78823   jresult = (int)result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78829   int jresult ;
78830   int result;
78831
78832   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78833   jresult = (int)result;
78834   return jresult;
78835 }
78836
78837
78838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78839   int jresult ;
78840   int result;
78841
78842   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78843   jresult = (int)result;
78844   return jresult;
78845 }
78846
78847
78848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78849   int jresult ;
78850   int result;
78851
78852   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78853   jresult = (int)result;
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78859   int jresult ;
78860   int result;
78861
78862   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78863   jresult = (int)result;
78864   return jresult;
78865 }
78866
78867
78868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78869   int jresult ;
78870   int result;
78871
78872   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78873   jresult = (int)result;
78874   return jresult;
78875 }
78876
78877
78878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78879   int jresult ;
78880   int result;
78881
78882   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78883   jresult = (int)result;
78884   return jresult;
78885 }
78886
78887
78888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78889   int jresult ;
78890   int result;
78891
78892   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78893   jresult = (int)result;
78894   return jresult;
78895 }
78896
78897
78898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78899   int jresult ;
78900   int result;
78901
78902   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78903   jresult = (int)result;
78904   return jresult;
78905 }
78906
78907
78908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78909   int jresult ;
78910   int result;
78911
78912   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78913   jresult = (int)result;
78914   return jresult;
78915 }
78916
78917
78918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78919   int jresult ;
78920   int result;
78921
78922   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78923   jresult = (int)result;
78924   return jresult;
78925 }
78926
78927
78928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78929   int jresult ;
78930   int result;
78931
78932   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78933   jresult = (int)result;
78934   return jresult;
78935 }
78936
78937
78938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78939   int jresult ;
78940   int result;
78941
78942   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78943   jresult = (int)result;
78944   return jresult;
78945 }
78946
78947
78948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78949   int jresult ;
78950   int result;
78951
78952   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78953   jresult = (int)result;
78954   return jresult;
78955 }
78956
78957
78958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78959   void * jresult ;
78960   Dali::Toolkit::TextField::Property *result = 0 ;
78961
78962   {
78963     try {
78964       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78965     } catch (std::out_of_range& e) {
78966       {
78967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (std::exception& e) {
78970       {
78971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78972       };
78973     } catch (...) {
78974       {
78975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78976       };
78977     }
78978   }
78979   jresult = (void *)result;
78980   return jresult;
78981 }
78982
78983
78984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78985   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78986
78987   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78988   {
78989     try {
78990       delete arg1;
78991     } catch (std::out_of_range& e) {
78992       {
78993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78994       };
78995     } catch (std::exception& e) {
78996       {
78997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78998       };
78999     } catch (...) {
79000       {
79001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79002       };
79003     }
79004   }
79005 }
79006
79007
79008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
79009   void * jresult ;
79010   Dali::Toolkit::TextField::InputStyle *result = 0 ;
79011
79012   {
79013     try {
79014       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
79015     } catch (std::out_of_range& e) {
79016       {
79017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79018       };
79019     } catch (std::exception& e) {
79020       {
79021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79022       };
79023     } catch (...) {
79024       {
79025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79026       };
79027     }
79028   }
79029   jresult = (void *)result;
79030   return jresult;
79031 }
79032
79033
79034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
79035   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
79036
79037   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
79038   {
79039     try {
79040       delete arg1;
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79052       };
79053     }
79054   }
79055 }
79056
79057
79058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
79059   void * jresult ;
79060   Dali::Toolkit::TextField result;
79061
79062   {
79063     try {
79064       result = Dali::Toolkit::TextField::New();
79065     } catch (std::out_of_range& e) {
79066       {
79067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79068       };
79069     } catch (std::exception& e) {
79070       {
79071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79072       };
79073     } catch (...) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79076       };
79077     }
79078   }
79079   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79080   return jresult;
79081 }
79082
79083
79084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
79085   void * jresult ;
79086   Dali::Toolkit::TextField *result = 0 ;
79087
79088   {
79089     try {
79090       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (...) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79102       };
79103     }
79104   }
79105   jresult = (void *)result;
79106   return jresult;
79107 }
79108
79109
79110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
79111   void * jresult ;
79112   Dali::Toolkit::TextField *arg1 = 0 ;
79113   Dali::Toolkit::TextField *result = 0 ;
79114
79115   arg1 = (Dali::Toolkit::TextField *)jarg1;
79116   if (!arg1) {
79117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79118     return 0;
79119   }
79120   {
79121     try {
79122       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (...) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79134       };
79135     }
79136   }
79137   jresult = (void *)result;
79138   return jresult;
79139 }
79140
79141
79142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79143   void * jresult ;
79144   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79145   Dali::Toolkit::TextField *arg2 = 0 ;
79146   Dali::Toolkit::TextField *result = 0 ;
79147
79148   arg1 = (Dali::Toolkit::TextField *)jarg1;
79149   arg2 = (Dali::Toolkit::TextField *)jarg2;
79150   if (!arg2) {
79151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79152     return 0;
79153   }
79154   {
79155     try {
79156       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79168       };
79169     }
79170   }
79171   jresult = (void *)result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79177   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79178
79179   arg1 = (Dali::Toolkit::TextField *)jarg1;
79180   {
79181     try {
79182       delete arg1;
79183     } catch (std::out_of_range& e) {
79184       {
79185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79186       };
79187     } catch (std::exception& e) {
79188       {
79189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79190       };
79191     } catch (...) {
79192       {
79193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79194       };
79195     }
79196   }
79197 }
79198
79199
79200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79201   void * jresult ;
79202   Dali::BaseHandle arg1 ;
79203   Dali::BaseHandle *argp1 ;
79204   Dali::Toolkit::TextField result;
79205
79206   argp1 = (Dali::BaseHandle *)jarg1;
79207   if (!argp1) {
79208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79209     return 0;
79210   }
79211   arg1 = *argp1;
79212   {
79213     try {
79214       result = Dali::Toolkit::TextField::DownCast(arg1);
79215     } catch (std::out_of_range& e) {
79216       {
79217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79218       };
79219     } catch (std::exception& e) {
79220       {
79221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79222       };
79223     } catch (...) {
79224       {
79225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79226       };
79227     }
79228   }
79229   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79230   return jresult;
79231 }
79232
79233
79234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79235   void * jresult ;
79236   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79237   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79238
79239   arg1 = (Dali::Toolkit::TextField *)jarg1;
79240   {
79241     try {
79242       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79243     } catch (std::out_of_range& e) {
79244       {
79245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79246       };
79247     } catch (std::exception& e) {
79248       {
79249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79250       };
79251     } catch (...) {
79252       {
79253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79254       };
79255     }
79256   }
79257   jresult = (void *)result;
79258   return jresult;
79259 }
79260
79261
79262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79263   void * jresult ;
79264   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79265   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79266
79267   arg1 = (Dali::Toolkit::TextField *)jarg1;
79268   {
79269     try {
79270       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (...) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79282       };
79283     }
79284   }
79285   jresult = (void *)result;
79286   return jresult;
79287 }
79288
79289
79290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79291   void * jresult ;
79292   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79293   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79294
79295   arg1 = (Dali::Toolkit::TextField *)jarg1;
79296   {
79297     try {
79298       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79299     } catch (std::out_of_range& e) {
79300       {
79301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79302       };
79303     } catch (std::exception& e) {
79304       {
79305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79306       };
79307     } catch (...) {
79308       {
79309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79310       };
79311     }
79312   }
79313   jresult = (void *)result;
79314   return jresult;
79315 }
79316
79317
79318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79319   int jresult ;
79320   int result;
79321
79322   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79323   jresult = (int)result;
79324   return jresult;
79325 }
79326
79327
79328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79329   int jresult ;
79330   int result;
79331
79332   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79333   jresult = (int)result;
79334   return jresult;
79335 }
79336
79337
79338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79339   int jresult ;
79340   int result;
79341
79342   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79343   jresult = (int)result;
79344   return jresult;
79345 }
79346
79347
79348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79349   int jresult ;
79350   int result;
79351
79352   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79353   jresult = (int)result;
79354   return jresult;
79355 }
79356
79357
79358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79359   int jresult ;
79360   int result;
79361
79362   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79363   jresult = (int)result;
79364   return jresult;
79365 }
79366
79367
79368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79369   int jresult ;
79370   int result;
79371
79372   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79373   jresult = (int)result;
79374   return jresult;
79375 }
79376
79377
79378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79379   int jresult ;
79380   int result;
79381
79382   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79383   jresult = (int)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79389   int jresult ;
79390   int result;
79391
79392   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79393   jresult = (int)result;
79394   return jresult;
79395 }
79396
79397
79398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79399   int jresult ;
79400   int result;
79401
79402   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79403   jresult = (int)result;
79404   return jresult;
79405 }
79406
79407
79408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79409   int jresult ;
79410   int result;
79411
79412   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79413   jresult = (int)result;
79414   return jresult;
79415 }
79416
79417
79418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79419   int jresult ;
79420   int result;
79421
79422   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79423   jresult = (int)result;
79424   return jresult;
79425 }
79426
79427
79428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79429   int jresult ;
79430   int result;
79431
79432   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79433   jresult = (int)result;
79434   return jresult;
79435 }
79436
79437
79438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79439   int jresult ;
79440   int result;
79441
79442   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79443   jresult = (int)result;
79444   return jresult;
79445 }
79446
79447
79448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79449   int jresult ;
79450   int result;
79451
79452   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79453   jresult = (int)result;
79454   return jresult;
79455 }
79456
79457
79458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79459   int jresult ;
79460   int result;
79461
79462   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79463   jresult = (int)result;
79464   return jresult;
79465 }
79466
79467
79468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79469   int jresult ;
79470   int result;
79471
79472   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79473   jresult = (int)result;
79474   return jresult;
79475 }
79476
79477
79478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79479   int jresult ;
79480   int result;
79481
79482   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79483   jresult = (int)result;
79484   return jresult;
79485 }
79486
79487
79488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79489   int jresult ;
79490   int result;
79491
79492   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79493   jresult = (int)result;
79494   return jresult;
79495 }
79496
79497
79498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79499   int jresult ;
79500   int result;
79501
79502   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79503   jresult = (int)result;
79504   return jresult;
79505 }
79506
79507
79508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79509   int jresult ;
79510   int result;
79511
79512   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79513   jresult = (int)result;
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79519   int jresult ;
79520   int result;
79521
79522   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79523   jresult = (int)result;
79524   return jresult;
79525 }
79526
79527
79528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79529   int jresult ;
79530   int result;
79531
79532   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79533   jresult = (int)result;
79534   return jresult;
79535 }
79536
79537
79538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79539   int jresult ;
79540   int result;
79541
79542   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79543   jresult = (int)result;
79544   return jresult;
79545 }
79546
79547
79548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79549   int jresult ;
79550   int result;
79551
79552   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79553   jresult = (int)result;
79554   return jresult;
79555 }
79556
79557
79558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79559   void * jresult ;
79560   Dali::Toolkit::TextLabel::Property *result = 0 ;
79561
79562   {
79563     try {
79564       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79565     } catch (std::out_of_range& e) {
79566       {
79567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79568       };
79569     } catch (std::exception& e) {
79570       {
79571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79572       };
79573     } catch (...) {
79574       {
79575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79576       };
79577     }
79578   }
79579   jresult = (void *)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79585   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79586
79587   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79588   {
79589     try {
79590       delete arg1;
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79598       };
79599     } catch (...) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79602       };
79603     }
79604   }
79605 }
79606
79607
79608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79609   void * jresult ;
79610   Dali::Toolkit::TextLabel result;
79611
79612   {
79613     try {
79614       result = Dali::Toolkit::TextLabel::New();
79615     } catch (std::out_of_range& e) {
79616       {
79617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79618       };
79619     } catch (std::exception& e) {
79620       {
79621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79622       };
79623     } catch (...) {
79624       {
79625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79626       };
79627     }
79628   }
79629   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79630   return jresult;
79631 }
79632
79633
79634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79635   void * jresult ;
79636   std::string *arg1 = 0 ;
79637   Dali::Toolkit::TextLabel result;
79638
79639   if (!jarg1) {
79640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79641     return 0;
79642   }
79643   std::string arg1_str(jarg1);
79644   arg1 = &arg1_str;
79645   {
79646     try {
79647       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79648     } catch (std::out_of_range& e) {
79649       {
79650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79651       };
79652     } catch (std::exception& e) {
79653       {
79654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79655       };
79656     } catch (...) {
79657       {
79658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79659       };
79660     }
79661   }
79662   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79663
79664   //argout typemap for const std::string&
79665
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79671   void * jresult ;
79672   Dali::Toolkit::TextLabel *result = 0 ;
79673
79674   {
79675     try {
79676       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79677     } catch (std::out_of_range& e) {
79678       {
79679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (std::exception& e) {
79682       {
79683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79688       };
79689     }
79690   }
79691   jresult = (void *)result;
79692   return jresult;
79693 }
79694
79695
79696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79697   void * jresult ;
79698   Dali::Toolkit::TextLabel *arg1 = 0 ;
79699   Dali::Toolkit::TextLabel *result = 0 ;
79700
79701   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79702   if (!arg1) {
79703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79704     return 0;
79705   }
79706   {
79707     try {
79708       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79709     } catch (std::out_of_range& e) {
79710       {
79711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79712       };
79713     } catch (std::exception& e) {
79714       {
79715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79716       };
79717     } catch (...) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79720       };
79721     }
79722   }
79723   jresult = (void *)result;
79724   return jresult;
79725 }
79726
79727
79728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79729   void * jresult ;
79730   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79731   Dali::Toolkit::TextLabel *arg2 = 0 ;
79732   Dali::Toolkit::TextLabel *result = 0 ;
79733
79734   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79735   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79736   if (!arg2) {
79737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79738     return 0;
79739   }
79740   {
79741     try {
79742       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79743     } catch (std::out_of_range& e) {
79744       {
79745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79746       };
79747     } catch (std::exception& e) {
79748       {
79749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79750       };
79751     } catch (...) {
79752       {
79753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79754       };
79755     }
79756   }
79757   jresult = (void *)result;
79758   return jresult;
79759 }
79760
79761
79762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79763   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79764
79765   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79766   {
79767     try {
79768       delete arg1;
79769     } catch (std::out_of_range& e) {
79770       {
79771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79772       };
79773     } catch (std::exception& e) {
79774       {
79775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79776       };
79777     } catch (...) {
79778       {
79779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79780       };
79781     }
79782   }
79783 }
79784
79785
79786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79787   void * jresult ;
79788   Dali::BaseHandle arg1 ;
79789   Dali::BaseHandle *argp1 ;
79790   Dali::Toolkit::TextLabel result;
79791
79792   argp1 = (Dali::BaseHandle *)jarg1;
79793   if (!argp1) {
79794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79795     return 0;
79796   }
79797   arg1 = *argp1;
79798   {
79799     try {
79800       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79801     } catch (std::out_of_range& e) {
79802       {
79803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79804       };
79805     } catch (std::exception& e) {
79806       {
79807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79808       };
79809     } catch (...) {
79810       {
79811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79812       };
79813     }
79814   }
79815   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79816   return jresult;
79817 }
79818
79819
79820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79821   void * jresult ;
79822   Dali::Toolkit::AccessibilityManager *result = 0 ;
79823
79824   {
79825     try {
79826       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79827     } catch (std::out_of_range& e) {
79828       {
79829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79830       };
79831     } catch (std::exception& e) {
79832       {
79833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79834       };
79835     } catch (...) {
79836       {
79837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79838       };
79839     }
79840   }
79841   jresult = (void *)result;
79842   return jresult;
79843 }
79844
79845
79846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79847   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79848
79849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79850   {
79851     try {
79852       delete arg1;
79853     } catch (std::out_of_range& e) {
79854       {
79855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79856       };
79857     } catch (std::exception& e) {
79858       {
79859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79860       };
79861     } catch (...) {
79862       {
79863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79864       };
79865     }
79866   }
79867 }
79868
79869
79870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79871   void * jresult ;
79872   Dali::Toolkit::AccessibilityManager result;
79873
79874   {
79875     try {
79876       result = Dali::Toolkit::AccessibilityManager::Get();
79877     } catch (std::out_of_range& e) {
79878       {
79879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (std::exception& e) {
79882       {
79883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79888       };
79889     }
79890   }
79891   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79892   return jresult;
79893 }
79894
79895
79896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79897   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79898   Dali::Actor arg2 ;
79899   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79900   std::string *arg4 = 0 ;
79901   Dali::Actor *argp2 ;
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 ;
79908   }
79909   arg2 = *argp2;
79910   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79911   if (!jarg4) {
79912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79913     return ;
79914   }
79915   std::string arg4_str(jarg4);
79916   arg4 = &arg4_str;
79917   {
79918     try {
79919       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79920     } catch (std::out_of_range& e) {
79921       {
79922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79923       };
79924     } catch (std::exception& e) {
79925       {
79926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79927       };
79928     } catch (...) {
79929       {
79930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79931       };
79932     }
79933   }
79934
79935   //argout typemap for const std::string&
79936
79937 }
79938
79939
79940 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79941   char * jresult ;
79942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79943   Dali::Actor arg2 ;
79944   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79945   Dali::Actor *argp2 ;
79946   std::string result;
79947
79948   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79949   argp2 = (Dali::Actor *)jarg2;
79950   if (!argp2) {
79951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79952     return 0;
79953   }
79954   arg2 = *argp2;
79955   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79956   {
79957     try {
79958       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79959     } catch (std::out_of_range& e) {
79960       {
79961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79962       };
79963     } catch (std::exception& e) {
79964       {
79965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79966       };
79967     } catch (...) {
79968       {
79969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79970       };
79971     }
79972   }
79973   jresult = SWIG_csharp_string_callback((&result)->c_str());
79974   return jresult;
79975 }
79976
79977
79978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79979   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79980   Dali::Actor arg2 ;
79981   unsigned int arg3 ;
79982   Dali::Actor *argp2 ;
79983
79984   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79985   argp2 = (Dali::Actor *)jarg2;
79986   if (!argp2) {
79987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79988     return ;
79989   }
79990   arg2 = *argp2;
79991   arg3 = (unsigned int)jarg3;
79992   {
79993     try {
79994       (arg1)->SetFocusOrder(arg2,arg3);
79995     } catch (std::out_of_range& e) {
79996       {
79997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79998       };
79999     } catch (std::exception& e) {
80000       {
80001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80002       };
80003     } catch (...) {
80004       {
80005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80006       };
80007     }
80008   }
80009 }
80010
80011
80012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
80013   unsigned int jresult ;
80014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80015   Dali::Actor arg2 ;
80016   Dali::Actor *argp2 ;
80017   unsigned int result;
80018
80019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80020   argp2 = (Dali::Actor *)jarg2;
80021   if (!argp2) {
80022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80023     return 0;
80024   }
80025   arg2 = *argp2;
80026   {
80027     try {
80028       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
80029     } catch (std::out_of_range& e) {
80030       {
80031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80032       };
80033     } catch (std::exception& e) {
80034       {
80035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80036       };
80037     } catch (...) {
80038       {
80039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80040       };
80041     }
80042   }
80043   jresult = result;
80044   return jresult;
80045 }
80046
80047
80048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80049   unsigned int jresult ;
80050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80051   unsigned int result;
80052
80053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80054   {
80055     try {
80056       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80064       };
80065     } catch (...) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80068       };
80069     }
80070   }
80071   jresult = result;
80072   return jresult;
80073 }
80074
80075
80076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80077   void * jresult ;
80078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80079   unsigned int arg2 ;
80080   Dali::Actor result;
80081
80082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80083   arg2 = (unsigned int)jarg2;
80084   {
80085     try {
80086       result = (arg1)->GetActorByFocusOrder(arg2);
80087     } catch (std::out_of_range& e) {
80088       {
80089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80090       };
80091     } catch (std::exception& e) {
80092       {
80093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80094       };
80095     } catch (...) {
80096       {
80097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80098       };
80099     }
80100   }
80101   jresult = new Dali::Actor((const Dali::Actor &)result);
80102   return jresult;
80103 }
80104
80105
80106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80107   unsigned int jresult ;
80108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80109   Dali::Actor arg2 ;
80110   Dali::Actor *argp2 ;
80111   bool result;
80112
80113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80114   argp2 = (Dali::Actor *)jarg2;
80115   if (!argp2) {
80116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80117     return 0;
80118   }
80119   arg2 = *argp2;
80120   {
80121     try {
80122       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80123     } catch (std::out_of_range& e) {
80124       {
80125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80126       };
80127     } catch (std::exception& e) {
80128       {
80129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80130       };
80131     } catch (...) {
80132       {
80133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80134       };
80135     }
80136   }
80137   jresult = result;
80138   return jresult;
80139 }
80140
80141
80142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80143   void * jresult ;
80144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80145   Dali::Actor result;
80146
80147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80148   {
80149     try {
80150       result = (arg1)->GetCurrentFocusActor();
80151     } catch (std::out_of_range& e) {
80152       {
80153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80154       };
80155     } catch (std::exception& e) {
80156       {
80157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80162       };
80163     }
80164   }
80165   jresult = new Dali::Actor((const Dali::Actor &)result);
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80171   void * jresult ;
80172   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80173   Dali::Actor result;
80174
80175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80176   {
80177     try {
80178       result = (arg1)->GetCurrentFocusGroup();
80179     } catch (std::out_of_range& e) {
80180       {
80181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80182       };
80183     } catch (std::exception& e) {
80184       {
80185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80186       };
80187     } catch (...) {
80188       {
80189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80190       };
80191     }
80192   }
80193   jresult = new Dali::Actor((const Dali::Actor &)result);
80194   return jresult;
80195 }
80196
80197
80198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80199   unsigned int jresult ;
80200   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80201   unsigned int result;
80202
80203   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80204   {
80205     try {
80206       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80207     } catch (std::out_of_range& e) {
80208       {
80209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80210       };
80211     } catch (std::exception& e) {
80212       {
80213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80214       };
80215     } catch (...) {
80216       {
80217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80218       };
80219     }
80220   }
80221   jresult = result;
80222   return jresult;
80223 }
80224
80225
80226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80227   unsigned int jresult ;
80228   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80229   bool result;
80230
80231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80232   {
80233     try {
80234       result = (bool)(arg1)->MoveFocusForward();
80235     } catch (std::out_of_range& e) {
80236       {
80237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80238       };
80239     } catch (std::exception& e) {
80240       {
80241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80242       };
80243     } catch (...) {
80244       {
80245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80246       };
80247     }
80248   }
80249   jresult = result;
80250   return jresult;
80251 }
80252
80253
80254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80255   unsigned int jresult ;
80256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80257   bool result;
80258
80259   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80260   {
80261     try {
80262       result = (bool)(arg1)->MoveFocusBackward();
80263     } catch (std::out_of_range& e) {
80264       {
80265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80266       };
80267     } catch (std::exception& e) {
80268       {
80269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80270       };
80271     } catch (...) {
80272       {
80273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80274       };
80275     }
80276   }
80277   jresult = result;
80278   return jresult;
80279 }
80280
80281
80282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80283   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80284
80285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80286   {
80287     try {
80288       (arg1)->ClearFocus();
80289     } catch (std::out_of_range& e) {
80290       {
80291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (std::exception& e) {
80294       {
80295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80296       };
80297     } catch (...) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80300       };
80301     }
80302   }
80303 }
80304
80305
80306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80307   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80308
80309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80310   {
80311     try {
80312       (arg1)->Reset();
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80320       };
80321     } catch (...) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80324       };
80325     }
80326   }
80327 }
80328
80329
80330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80332   Dali::Actor arg2 ;
80333   bool arg3 ;
80334   Dali::Actor *argp2 ;
80335
80336   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80337   argp2 = (Dali::Actor *)jarg2;
80338   if (!argp2) {
80339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80340     return ;
80341   }
80342   arg2 = *argp2;
80343   arg3 = jarg3 ? true : false;
80344   {
80345     try {
80346       (arg1)->SetFocusGroup(arg2,arg3);
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_IsFocusGroup(void * jarg1, void * jarg2) {
80365   unsigned int jresult ;
80366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80367   Dali::Actor arg2 ;
80368   Dali::Actor *argp2 ;
80369   bool result;
80370
80371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80372   argp2 = (Dali::Actor *)jarg2;
80373   if (!argp2) {
80374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80375     return 0;
80376   }
80377   arg2 = *argp2;
80378   {
80379     try {
80380       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80381     } catch (std::out_of_range& e) {
80382       {
80383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (std::exception& e) {
80386       {
80387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395   jresult = result;
80396   return jresult;
80397 }
80398
80399
80400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80401   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80402   bool arg2 ;
80403
80404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80405   arg2 = jarg2 ? true : false;
80406   {
80407     try {
80408       (arg1)->SetGroupMode(arg2);
80409     } catch (std::out_of_range& e) {
80410       {
80411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80412       };
80413     } catch (std::exception& e) {
80414       {
80415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80416       };
80417     } catch (...) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80420       };
80421     }
80422   }
80423 }
80424
80425
80426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80427   unsigned int jresult ;
80428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80429   bool result;
80430
80431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80432   {
80433     try {
80434       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80435     } catch (std::out_of_range& e) {
80436       {
80437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80438       };
80439     } catch (std::exception& e) {
80440       {
80441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80442       };
80443     } catch (...) {
80444       {
80445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80446       };
80447     }
80448   }
80449   jresult = result;
80450   return jresult;
80451 }
80452
80453
80454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80456   bool arg2 ;
80457
80458   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80459   arg2 = jarg2 ? true : false;
80460   {
80461     try {
80462       (arg1)->SetWrapMode(arg2);
80463     } catch (std::out_of_range& e) {
80464       {
80465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80466       };
80467     } catch (std::exception& e) {
80468       {
80469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80470       };
80471     } catch (...) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80474       };
80475     }
80476   }
80477 }
80478
80479
80480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80481   unsigned int jresult ;
80482   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80483   bool result;
80484
80485   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80486   {
80487     try {
80488       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (...) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80500       };
80501     }
80502   }
80503   jresult = result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80510   Dali::Actor arg2 ;
80511   Dali::Actor *argp2 ;
80512
80513   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80514   argp2 = (Dali::Actor *)jarg2;
80515   if (!argp2) {
80516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80517     return ;
80518   }
80519   arg2 = *argp2;
80520   {
80521     try {
80522       (arg1)->SetFocusIndicatorActor(arg2);
80523     } catch (std::out_of_range& e) {
80524       {
80525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (std::exception& e) {
80528       {
80529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80530       };
80531     } catch (...) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80534       };
80535     }
80536   }
80537 }
80538
80539
80540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80541   void * jresult ;
80542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80543   Dali::Actor result;
80544
80545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80546   {
80547     try {
80548       result = (arg1)->GetFocusIndicatorActor();
80549     } catch (std::out_of_range& e) {
80550       {
80551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (std::exception& e) {
80554       {
80555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80556       };
80557     } catch (...) {
80558       {
80559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80560       };
80561     }
80562   }
80563   jresult = new Dali::Actor((const Dali::Actor &)result);
80564   return jresult;
80565 }
80566
80567
80568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80569   void * jresult ;
80570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80571   Dali::Actor arg2 ;
80572   Dali::Actor *argp2 ;
80573   Dali::Actor result;
80574
80575   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80576   argp2 = (Dali::Actor *)jarg2;
80577   if (!argp2) {
80578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80579     return 0;
80580   }
80581   arg2 = *argp2;
80582   {
80583     try {
80584       result = (arg1)->GetFocusGroup(arg2);
80585     } catch (std::out_of_range& e) {
80586       {
80587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (std::exception& e) {
80590       {
80591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80596       };
80597     }
80598   }
80599   jresult = new Dali::Actor((const Dali::Actor &)result);
80600   return jresult;
80601 }
80602
80603
80604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80605   void * jresult ;
80606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80607   Dali::Vector2 result;
80608
80609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80610   {
80611     try {
80612       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80620       };
80621     } catch (...) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80624       };
80625     }
80626   }
80627   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80628   return jresult;
80629 }
80630
80631
80632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80633   void * jresult ;
80634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80635   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80636
80637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80638   {
80639     try {
80640       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80641     } catch (std::out_of_range& e) {
80642       {
80643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (std::exception& e) {
80646       {
80647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80648       };
80649     } catch (...) {
80650       {
80651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80652       };
80653     }
80654   }
80655   jresult = (void *)result;
80656   return jresult;
80657 }
80658
80659
80660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80661   void * jresult ;
80662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80663   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80664
80665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80666   {
80667     try {
80668       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80669     } catch (std::out_of_range& e) {
80670       {
80671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80672       };
80673     } catch (std::exception& e) {
80674       {
80675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80676       };
80677     } catch (...) {
80678       {
80679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80680       };
80681     }
80682   }
80683   jresult = (void *)result;
80684   return jresult;
80685 }
80686
80687
80688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80689   void * jresult ;
80690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80691   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80692
80693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80694   {
80695     try {
80696       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80697     } catch (std::out_of_range& e) {
80698       {
80699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80700       };
80701     } catch (std::exception& e) {
80702       {
80703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80704       };
80705     } catch (...) {
80706       {
80707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80708       };
80709     }
80710   }
80711   jresult = (void *)result;
80712   return jresult;
80713 }
80714
80715
80716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80717   void * jresult ;
80718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80720
80721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80722   {
80723     try {
80724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80725     } catch (std::out_of_range& e) {
80726       {
80727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80728       };
80729     } catch (std::exception& e) {
80730       {
80731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80732       };
80733     } catch (...) {
80734       {
80735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80736       };
80737     }
80738   }
80739   jresult = (void *)result;
80740   return jresult;
80741 }
80742
80743
80744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80745   void * jresult ;
80746   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80747   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80748
80749   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80750   {
80751     try {
80752       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80753     } catch (std::out_of_range& e) {
80754       {
80755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (std::exception& e) {
80758       {
80759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80764       };
80765     }
80766   }
80767   jresult = (void *)result;
80768   return jresult;
80769 }
80770
80771
80772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80773   void * jresult ;
80774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80775   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80776
80777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80778   {
80779     try {
80780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80781     } catch (std::out_of_range& e) {
80782       {
80783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80784       };
80785     } catch (std::exception& e) {
80786       {
80787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80788       };
80789     } catch (...) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80792       };
80793     }
80794   }
80795   jresult = (void *)result;
80796   return jresult;
80797 }
80798
80799
80800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80801   void * jresult ;
80802   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80803   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80804
80805   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80806   {
80807     try {
80808       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80809     } catch (std::out_of_range& e) {
80810       {
80811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (std::exception& e) {
80814       {
80815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80816       };
80817     } catch (...) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80820       };
80821     }
80822   }
80823   jresult = (void *)result;
80824   return jresult;
80825 }
80826
80827
80828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80829   void * jresult ;
80830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80831   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80832
80833   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80834   {
80835     try {
80836       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80837     } catch (std::out_of_range& e) {
80838       {
80839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (std::exception& e) {
80842       {
80843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80848       };
80849     }
80850   }
80851   jresult = (void *)result;
80852   return jresult;
80853 }
80854
80855
80856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80857   void * jresult ;
80858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80859   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80860
80861   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80862   {
80863     try {
80864       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80865     } catch (std::out_of_range& e) {
80866       {
80867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80868       };
80869     } catch (std::exception& e) {
80870       {
80871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80876       };
80877     }
80878   }
80879   jresult = (void *)result;
80880   return jresult;
80881 }
80882
80883
80884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80885   void * jresult ;
80886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80887   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80888
80889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80890   {
80891     try {
80892       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80893     } catch (std::out_of_range& e) {
80894       {
80895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80896       };
80897     } catch (std::exception& e) {
80898       {
80899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (...) {
80902       {
80903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80904       };
80905     }
80906   }
80907   jresult = (void *)result;
80908   return jresult;
80909 }
80910
80911
80912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80913   void * jresult ;
80914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80915   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80916
80917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80918   {
80919     try {
80920       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80921     } catch (std::out_of_range& e) {
80922       {
80923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80924       };
80925     } catch (std::exception& e) {
80926       {
80927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80928       };
80929     } catch (...) {
80930       {
80931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80932       };
80933     }
80934   }
80935   jresult = (void *)result;
80936   return jresult;
80937 }
80938
80939
80940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80941   void * jresult ;
80942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80944
80945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80946   {
80947     try {
80948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80949     } catch (std::out_of_range& e) {
80950       {
80951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80952       };
80953     } catch (std::exception& e) {
80954       {
80955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80956       };
80957     } catch (...) {
80958       {
80959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80960       };
80961     }
80962   }
80963   jresult = (void *)result;
80964   return jresult;
80965 }
80966
80967
80968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80969   void * jresult ;
80970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80971   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80972
80973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80974   {
80975     try {
80976       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80977     } catch (std::out_of_range& e) {
80978       {
80979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (std::exception& e) {
80982       {
80983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80984       };
80985     } catch (...) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80988       };
80989     }
80990   }
80991   jresult = (void *)result;
80992   return jresult;
80993 }
80994
80995
80996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80997   void * jresult ;
80998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81000
81001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81002   {
81003     try {
81004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
81005     } catch (std::out_of_range& e) {
81006       {
81007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81008       };
81009     } catch (std::exception& e) {
81010       {
81011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81012       };
81013     } catch (...) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81016       };
81017     }
81018   }
81019   jresult = (void *)result;
81020   return jresult;
81021 }
81022
81023
81024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81025   void * jresult ;
81026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81028
81029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81030   {
81031     try {
81032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81033     } catch (std::out_of_range& e) {
81034       {
81035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81036       };
81037     } catch (std::exception& e) {
81038       {
81039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81040       };
81041     } catch (...) {
81042       {
81043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81044       };
81045     }
81046   }
81047   jresult = (void *)result;
81048   return jresult;
81049 }
81050
81051
81052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81053   void * jresult ;
81054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81055   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81056
81057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81058   {
81059     try {
81060       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81061     } catch (std::out_of_range& e) {
81062       {
81063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (std::exception& e) {
81066       {
81067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81072       };
81073     }
81074   }
81075   jresult = (void *)result;
81076   return jresult;
81077 }
81078
81079
81080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81081   void * jresult ;
81082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81083   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81084
81085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81086   {
81087     try {
81088       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81089     } catch (std::out_of_range& e) {
81090       {
81091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81092       };
81093     } catch (std::exception& e) {
81094       {
81095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81096       };
81097     } catch (...) {
81098       {
81099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81100       };
81101     }
81102   }
81103   jresult = (void *)result;
81104   return jresult;
81105 }
81106
81107
81108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81109   void * jresult ;
81110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81111   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81112
81113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81114   {
81115     try {
81116       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81117     } catch (std::out_of_range& e) {
81118       {
81119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (std::exception& e) {
81122       {
81123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81128       };
81129     }
81130   }
81131   jresult = (void *)result;
81132   return jresult;
81133 }
81134
81135
81136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81137   void * jresult ;
81138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81140
81141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81142   {
81143     try {
81144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (...) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81156       };
81157     }
81158   }
81159   jresult = (void *)result;
81160   return jresult;
81161 }
81162
81163
81164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81165   void * jresult ;
81166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81167   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81168
81169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81170   {
81171     try {
81172       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81173     } catch (std::out_of_range& e) {
81174       {
81175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81176       };
81177     } catch (std::exception& e) {
81178       {
81179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81180       };
81181     } catch (...) {
81182       {
81183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81184       };
81185     }
81186   }
81187   jresult = (void *)result;
81188   return jresult;
81189 }
81190
81191
81192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81193   void * jresult ;
81194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81195   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81196
81197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81198   {
81199     try {
81200       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81201     } catch (std::out_of_range& e) {
81202       {
81203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81204       };
81205     } catch (std::exception& e) {
81206       {
81207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81208       };
81209     } catch (...) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81212       };
81213     }
81214   }
81215   jresult = (void *)result;
81216   return jresult;
81217 }
81218
81219
81220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81221   void * jresult ;
81222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81223   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81224
81225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81226   {
81227     try {
81228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81229     } catch (std::out_of_range& e) {
81230       {
81231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81232       };
81233     } catch (std::exception& e) {
81234       {
81235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81236       };
81237     } catch (...) {
81238       {
81239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81240       };
81241     }
81242   }
81243   jresult = (void *)result;
81244   return jresult;
81245 }
81246
81247
81248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81249   void * jresult ;
81250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81251   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81252
81253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81254   {
81255     try {
81256       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81257     } catch (std::out_of_range& e) {
81258       {
81259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81260       };
81261     } catch (std::exception& e) {
81262       {
81263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81264       };
81265     } catch (...) {
81266       {
81267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81268       };
81269     }
81270   }
81271   jresult = (void *)result;
81272   return jresult;
81273 }
81274
81275
81276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81277   void * jresult ;
81278   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81279   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81280
81281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81282   {
81283     try {
81284       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81285     } catch (std::out_of_range& e) {
81286       {
81287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81288       };
81289     } catch (std::exception& e) {
81290       {
81291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81292       };
81293     } catch (...) {
81294       {
81295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81296       };
81297     }
81298   }
81299   jresult = (void *)result;
81300   return jresult;
81301 }
81302
81303
81304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81305   void * jresult ;
81306   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81307   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81308
81309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81310   {
81311     try {
81312       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81313     } catch (std::out_of_range& e) {
81314       {
81315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (std::exception& e) {
81318       {
81319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81320       };
81321     } catch (...) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81324       };
81325     }
81326   }
81327   jresult = (void *)result;
81328   return jresult;
81329 }
81330
81331
81332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81333   void * jresult ;
81334   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81335   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81336
81337   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81338   {
81339     try {
81340       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81341     } catch (std::out_of_range& e) {
81342       {
81343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (std::exception& e) {
81346       {
81347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81352       };
81353     }
81354   }
81355   jresult = (void *)result;
81356   return jresult;
81357 }
81358
81359
81360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81361   void * jresult ;
81362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81363   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81364
81365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81366   {
81367     try {
81368       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81369     } catch (std::out_of_range& e) {
81370       {
81371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81372       };
81373     } catch (std::exception& e) {
81374       {
81375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (...) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81380       };
81381     }
81382   }
81383   jresult = (void *)result;
81384   return jresult;
81385 }
81386
81387
81388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81389   void * jresult ;
81390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81391   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81392
81393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81394   {
81395     try {
81396       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81397     } catch (std::out_of_range& e) {
81398       {
81399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81400       };
81401     } catch (std::exception& e) {
81402       {
81403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81404       };
81405     } catch (...) {
81406       {
81407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81408       };
81409     }
81410   }
81411   jresult = (void *)result;
81412   return jresult;
81413 }
81414
81415
81416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81417   void * jresult ;
81418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81419   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81420
81421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81422   {
81423     try {
81424       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81425     } catch (std::out_of_range& e) {
81426       {
81427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81428       };
81429     } catch (std::exception& e) {
81430       {
81431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81432       };
81433     } catch (...) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81436       };
81437     }
81438   }
81439   jresult = (void *)result;
81440   return jresult;
81441 }
81442
81443
81444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81445   void * jresult ;
81446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81447   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81448
81449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81450   {
81451     try {
81452       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81453     } catch (std::out_of_range& e) {
81454       {
81455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81456       };
81457     } catch (std::exception& e) {
81458       {
81459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81460       };
81461     } catch (...) {
81462       {
81463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81464       };
81465     }
81466   }
81467   jresult = (void *)result;
81468   return jresult;
81469 }
81470
81471
81472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81473   void * jresult ;
81474   Dali::Toolkit::StyleManager *result = 0 ;
81475
81476   {
81477     try {
81478       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81479     } catch (std::out_of_range& e) {
81480       {
81481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81482       };
81483     } catch (std::exception& e) {
81484       {
81485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81486       };
81487     } catch (...) {
81488       {
81489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81490       };
81491     }
81492   }
81493   jresult = (void *)result;
81494   return jresult;
81495 }
81496
81497
81498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81499   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81500
81501   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81502   {
81503     try {
81504       delete arg1;
81505     } catch (std::out_of_range& e) {
81506       {
81507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (std::exception& e) {
81510       {
81511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81516       };
81517     }
81518   }
81519 }
81520
81521
81522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81523   void * jresult ;
81524   Dali::Toolkit::StyleManager result;
81525
81526   {
81527     try {
81528       result = Dali::Toolkit::StyleManager::Get();
81529     } catch (std::out_of_range& e) {
81530       {
81531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81532       };
81533     } catch (std::exception& e) {
81534       {
81535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81536       };
81537     } catch (...) {
81538       {
81539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81540       };
81541     }
81542   }
81543   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81544   return jresult;
81545 }
81546
81547
81548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81549   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81550   std::string *arg2 = 0 ;
81551
81552   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81553   if (!jarg2) {
81554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81555     return ;
81556   }
81557   std::string arg2_str(jarg2);
81558   arg2 = &arg2_str;
81559   {
81560     try {
81561       (arg1)->ApplyTheme((std::string const &)*arg2);
81562     } catch (std::out_of_range& e) {
81563       {
81564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81565       };
81566     } catch (std::exception& e) {
81567       {
81568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81569       };
81570     } catch (...) {
81571       {
81572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81573       };
81574     }
81575   }
81576
81577   //argout typemap for const std::string&
81578
81579 }
81580
81581
81582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81583   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81584
81585   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81586   {
81587     try {
81588       (arg1)->ApplyDefaultTheme();
81589     } catch (std::out_of_range& e) {
81590       {
81591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81592       };
81593     } catch (std::exception& e) {
81594       {
81595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81596       };
81597     } catch (...) {
81598       {
81599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81600       };
81601     }
81602   }
81603 }
81604
81605
81606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81607   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81608   std::string *arg2 = 0 ;
81609   Dali::Property::Value *arg3 = 0 ;
81610
81611   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81612   if (!jarg2) {
81613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81614     return ;
81615   }
81616   std::string arg2_str(jarg2);
81617   arg2 = &arg2_str;
81618   arg3 = (Dali::Property::Value *)jarg3;
81619   if (!arg3) {
81620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81621     return ;
81622   }
81623   {
81624     try {
81625       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81626     } catch (std::out_of_range& e) {
81627       {
81628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81629       };
81630     } catch (std::exception& e) {
81631       {
81632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81633       };
81634     } catch (...) {
81635       {
81636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81637       };
81638     }
81639   }
81640
81641   //argout typemap for const std::string&
81642
81643 }
81644
81645
81646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81647   unsigned int jresult ;
81648   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81649   std::string *arg2 = 0 ;
81650   Dali::Property::Value *arg3 = 0 ;
81651   bool result;
81652
81653   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81654   if (!jarg2) {
81655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81656     return 0;
81657   }
81658   std::string arg2_str(jarg2);
81659   arg2 = &arg2_str;
81660   arg3 = (Dali::Property::Value *)jarg3;
81661   if (!arg3) {
81662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81663     return 0;
81664   }
81665   {
81666     try {
81667       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81668     } catch (std::out_of_range& e) {
81669       {
81670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81671       };
81672     } catch (std::exception& e) {
81673       {
81674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (...) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81679       };
81680     }
81681   }
81682   jresult = result;
81683
81684   //argout typemap for const std::string&
81685
81686   return jresult;
81687 }
81688
81689
81690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81691   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81692   Dali::Toolkit::Control arg2 ;
81693   std::string *arg3 = 0 ;
81694   std::string *arg4 = 0 ;
81695   Dali::Toolkit::Control *argp2 ;
81696
81697   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81698   argp2 = (Dali::Toolkit::Control *)jarg2;
81699   if (!argp2) {
81700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81701     return ;
81702   }
81703   arg2 = *argp2;
81704   if (!jarg3) {
81705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81706     return ;
81707   }
81708   std::string arg3_str(jarg3);
81709   arg3 = &arg3_str;
81710   if (!jarg4) {
81711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81712     return ;
81713   }
81714   std::string arg4_str(jarg4);
81715   arg4 = &arg4_str;
81716   {
81717     try {
81718       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81719     } catch (std::out_of_range& e) {
81720       {
81721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81722       };
81723     } catch (std::exception& e) {
81724       {
81725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (...) {
81728       {
81729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81730       };
81731     }
81732   }
81733
81734   //argout typemap for const std::string&
81735
81736
81737   //argout typemap for const std::string&
81738
81739 }
81740
81741
81742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81743   void * jresult ;
81744   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81745   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81746
81747   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81748   {
81749     try {
81750       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81751     } catch (std::out_of_range& e) {
81752       {
81753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81754       };
81755     } catch (std::exception& e) {
81756       {
81757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81758       };
81759     } catch (...) {
81760       {
81761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81762       };
81763     }
81764   }
81765   jresult = (void *)result;
81766   return jresult;
81767 }
81768
81769
81770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81771   int jresult ;
81772   int result;
81773
81774   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81775   jresult = (int)result;
81776   return jresult;
81777 }
81778
81779
81780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81781   int jresult ;
81782   int result;
81783
81784   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81785   jresult = (int)result;
81786   return jresult;
81787 }
81788
81789
81790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81791   int jresult ;
81792   int result;
81793
81794   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81795   jresult = (int)result;
81796   return jresult;
81797 }
81798
81799
81800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81801   int jresult ;
81802   int result;
81803
81804   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81805   jresult = (int)result;
81806   return jresult;
81807 }
81808
81809
81810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81811   int jresult ;
81812   int result;
81813
81814   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81815   jresult = (int)result;
81816   return jresult;
81817 }
81818
81819
81820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81821   int jresult ;
81822   int result;
81823
81824   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81825   jresult = (int)result;
81826   return jresult;
81827 }
81828
81829
81830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81831   int jresult ;
81832   int result;
81833
81834   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81835   jresult = (int)result;
81836   return jresult;
81837 }
81838
81839
81840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81841   int jresult ;
81842   int result;
81843
81844   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81845   jresult = (int)result;
81846   return jresult;
81847 }
81848
81849
81850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81851   int jresult ;
81852   int result;
81853
81854   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81855   jresult = (int)result;
81856   return jresult;
81857 }
81858
81859
81860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81861   int jresult ;
81862   int result;
81863
81864   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81865   jresult = (int)result;
81866   return jresult;
81867 }
81868
81869
81870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81871   int jresult ;
81872   int result;
81873
81874   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81875   jresult = (int)result;
81876   return jresult;
81877 }
81878
81879
81880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81881   int jresult ;
81882   int result;
81883
81884   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81885   jresult = (int)result;
81886   return jresult;
81887 }
81888
81889
81890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81891   int jresult ;
81892   int result;
81893
81894   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81895   jresult = (int)result;
81896   return jresult;
81897 }
81898
81899
81900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81901   int jresult ;
81902   int result;
81903
81904   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81905   jresult = (int)result;
81906   return jresult;
81907 }
81908
81909
81910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81911   int jresult ;
81912   int result;
81913
81914   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81915   jresult = (int)result;
81916   return jresult;
81917 }
81918
81919
81920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81921   void * jresult ;
81922   Dali::Toolkit::Slider::Property *result = 0 ;
81923
81924   {
81925     try {
81926       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81927     } catch (std::out_of_range& e) {
81928       {
81929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81930       };
81931     } catch (std::exception& e) {
81932       {
81933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81938       };
81939     }
81940   }
81941   jresult = (void *)result;
81942   return jresult;
81943 }
81944
81945
81946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81947   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81948
81949   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81950   {
81951     try {
81952       delete arg1;
81953     } catch (std::out_of_range& e) {
81954       {
81955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81956       };
81957     } catch (std::exception& e) {
81958       {
81959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81964       };
81965     }
81966   }
81967 }
81968
81969
81970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81971   void * jresult ;
81972   Dali::Toolkit::Slider result;
81973
81974   {
81975     try {
81976       result = Dali::Toolkit::Slider::New();
81977     } catch (std::out_of_range& e) {
81978       {
81979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81980       };
81981     } catch (std::exception& e) {
81982       {
81983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (...) {
81986       {
81987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81988       };
81989     }
81990   }
81991   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81992   return jresult;
81993 }
81994
81995
81996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81997   void * jresult ;
81998   Dali::Toolkit::Slider *result = 0 ;
81999
82000   {
82001     try {
82002       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82010       };
82011     } catch (...) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82014       };
82015     }
82016   }
82017   jresult = (void *)result;
82018   return jresult;
82019 }
82020
82021
82022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
82023   void * jresult ;
82024   Dali::Toolkit::Slider *arg1 = 0 ;
82025   Dali::Toolkit::Slider *result = 0 ;
82026
82027   arg1 = (Dali::Toolkit::Slider *)jarg1;
82028   if (!arg1) {
82029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82030     return 0;
82031   }
82032   {
82033     try {
82034       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
82035     } catch (std::out_of_range& e) {
82036       {
82037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82038       };
82039     } catch (std::exception& e) {
82040       {
82041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82042       };
82043     } catch (...) {
82044       {
82045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82046       };
82047     }
82048   }
82049   jresult = (void *)result;
82050   return jresult;
82051 }
82052
82053
82054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82055   void * jresult ;
82056   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82057   Dali::Toolkit::Slider *arg2 = 0 ;
82058   Dali::Toolkit::Slider *result = 0 ;
82059
82060   arg1 = (Dali::Toolkit::Slider *)jarg1;
82061   arg2 = (Dali::Toolkit::Slider *)jarg2;
82062   if (!arg2) {
82063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82064     return 0;
82065   }
82066   {
82067     try {
82068       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (...) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82080       };
82081     }
82082   }
82083   jresult = (void *)result;
82084   return jresult;
82085 }
82086
82087
82088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82089   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82090
82091   arg1 = (Dali::Toolkit::Slider *)jarg1;
82092   {
82093     try {
82094       delete arg1;
82095     } catch (std::out_of_range& e) {
82096       {
82097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82098       };
82099     } catch (std::exception& e) {
82100       {
82101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (...) {
82104       {
82105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82106       };
82107     }
82108   }
82109 }
82110
82111
82112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82113   void * jresult ;
82114   Dali::BaseHandle arg1 ;
82115   Dali::BaseHandle *argp1 ;
82116   Dali::Toolkit::Slider result;
82117
82118   argp1 = (Dali::BaseHandle *)jarg1;
82119   if (!argp1) {
82120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82121     return 0;
82122   }
82123   arg1 = *argp1;
82124   {
82125     try {
82126       result = Dali::Toolkit::Slider::DownCast(arg1);
82127     } catch (std::out_of_range& e) {
82128       {
82129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82130       };
82131     } catch (std::exception& e) {
82132       {
82133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82134       };
82135     } catch (...) {
82136       {
82137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82138       };
82139     }
82140   }
82141   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82142   return jresult;
82143 }
82144
82145
82146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82147   void * jresult ;
82148   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82149   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82150
82151   arg1 = (Dali::Toolkit::Slider *)jarg1;
82152   {
82153     try {
82154       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82155     } catch (std::out_of_range& e) {
82156       {
82157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82158       };
82159     } catch (std::exception& e) {
82160       {
82161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82162       };
82163     } catch (...) {
82164       {
82165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82166       };
82167     }
82168   }
82169   jresult = (void *)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82175   void * jresult ;
82176   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82177   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82178
82179   arg1 = (Dali::Toolkit::Slider *)jarg1;
82180   {
82181     try {
82182       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82183     } catch (std::out_of_range& e) {
82184       {
82185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82186       };
82187     } catch (std::exception& e) {
82188       {
82189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82194       };
82195     }
82196   }
82197   jresult = (void *)result;
82198   return jresult;
82199 }
82200
82201
82202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82203   void * jresult ;
82204   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82205   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82206
82207   arg1 = (Dali::Toolkit::Slider *)jarg1;
82208   {
82209     try {
82210       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
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 = (void *)result;
82226   return jresult;
82227 }
82228
82229
82230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82231   int jresult ;
82232   int result;
82233
82234   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82235   jresult = (int)result;
82236   return jresult;
82237 }
82238
82239
82240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82241   int jresult ;
82242   int result;
82243
82244   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82245   jresult = (int)result;
82246   return jresult;
82247 }
82248
82249
82250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82251   int jresult ;
82252   int result;
82253
82254   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82255   jresult = (int)result;
82256   return jresult;
82257 }
82258
82259
82260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82261   int jresult ;
82262   int result;
82263
82264   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82265   jresult = (int)result;
82266   return jresult;
82267 }
82268
82269
82270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82271   void * jresult ;
82272   Dali::Toolkit::VideoView::Property *result = 0 ;
82273
82274   {
82275     try {
82276       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82277     } catch (std::out_of_range& e) {
82278       {
82279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82280       };
82281     } catch (std::exception& e) {
82282       {
82283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82284       };
82285     } catch (...) {
82286       {
82287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82288       };
82289     }
82290   }
82291   jresult = (void *)result;
82292   return jresult;
82293 }
82294
82295
82296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82297   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82298
82299   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82300   {
82301     try {
82302       delete arg1;
82303     } catch (std::out_of_range& e) {
82304       {
82305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (std::exception& e) {
82308       {
82309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82310       };
82311     } catch (...) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82314       };
82315     }
82316   }
82317 }
82318
82319
82320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82321   void * jresult ;
82322   Dali::Toolkit::VideoView result;
82323
82324   {
82325     try {
82326       result = Dali::Toolkit::VideoView::New();
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82338       };
82339     }
82340   }
82341   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82342   return jresult;
82343 }
82344
82345
82346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82347   void * jresult ;
82348   std::string *arg1 = 0 ;
82349   Dali::Toolkit::VideoView result;
82350
82351   if (!jarg1) {
82352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82353     return 0;
82354   }
82355   std::string arg1_str(jarg1);
82356   arg1 = &arg1_str;
82357   {
82358     try {
82359       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82360     } catch (std::out_of_range& e) {
82361       {
82362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82363       };
82364     } catch (std::exception& e) {
82365       {
82366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82367       };
82368     } catch (...) {
82369       {
82370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82371       };
82372     }
82373   }
82374   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82375
82376   //argout typemap for const std::string&
82377
82378   return jresult;
82379 }
82380
82381
82382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82383   void * jresult ;
82384   Dali::Toolkit::VideoView *result = 0 ;
82385
82386   {
82387     try {
82388       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82389     } catch (std::out_of_range& e) {
82390       {
82391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82392       };
82393     } catch (std::exception& e) {
82394       {
82395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82396       };
82397     } catch (...) {
82398       {
82399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82400       };
82401     }
82402   }
82403   jresult = (void *)result;
82404   return jresult;
82405 }
82406
82407
82408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82409   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82410
82411   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82412   {
82413     try {
82414       delete arg1;
82415     } catch (std::out_of_range& e) {
82416       {
82417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82418       };
82419     } catch (std::exception& e) {
82420       {
82421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82422       };
82423     } catch (...) {
82424       {
82425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82426       };
82427     }
82428   }
82429 }
82430
82431
82432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82433   void * jresult ;
82434   Dali::Toolkit::VideoView *arg1 = 0 ;
82435   Dali::Toolkit::VideoView *result = 0 ;
82436
82437   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82438   if (!arg1) {
82439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82440     return 0;
82441   }
82442   {
82443     try {
82444       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82445     } catch (std::out_of_range& e) {
82446       {
82447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82448       };
82449     } catch (std::exception& e) {
82450       {
82451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82452       };
82453     } catch (...) {
82454       {
82455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82456       };
82457     }
82458   }
82459   jresult = (void *)result;
82460   return jresult;
82461 }
82462
82463
82464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82465   void * jresult ;
82466   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82467   Dali::Toolkit::VideoView *arg2 = 0 ;
82468   Dali::Toolkit::VideoView *result = 0 ;
82469
82470   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82471   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82472   if (!arg2) {
82473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82474     return 0;
82475   }
82476   {
82477     try {
82478       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82479     } catch (std::out_of_range& e) {
82480       {
82481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82482       };
82483     } catch (std::exception& e) {
82484       {
82485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82486       };
82487     } catch (...) {
82488       {
82489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82490       };
82491     }
82492   }
82493   jresult = (void *)result;
82494   return jresult;
82495 }
82496
82497
82498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82499   void * jresult ;
82500   Dali::BaseHandle arg1 ;
82501   Dali::BaseHandle *argp1 ;
82502   Dali::Toolkit::VideoView result;
82503
82504   argp1 = (Dali::BaseHandle *)jarg1;
82505   if (!argp1) {
82506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82507     return 0;
82508   }
82509   arg1 = *argp1;
82510   {
82511     try {
82512       result = Dali::Toolkit::VideoView::DownCast(arg1);
82513     } catch (std::out_of_range& e) {
82514       {
82515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82516       };
82517     } catch (std::exception& e) {
82518       {
82519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82520       };
82521     } catch (...) {
82522       {
82523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82524       };
82525     }
82526   }
82527   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82533   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82534
82535   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82536   {
82537     try {
82538       (arg1)->Play();
82539     } catch (std::out_of_range& e) {
82540       {
82541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82542       };
82543     } catch (std::exception& e) {
82544       {
82545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82546       };
82547     } catch (...) {
82548       {
82549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82550       };
82551     }
82552   }
82553 }
82554
82555
82556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82557   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82558
82559   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82560   {
82561     try {
82562       (arg1)->Pause();
82563     } catch (std::out_of_range& e) {
82564       {
82565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82566       };
82567     } catch (std::exception& e) {
82568       {
82569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82570       };
82571     } catch (...) {
82572       {
82573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82574       };
82575     }
82576   }
82577 }
82578
82579
82580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82581   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82582
82583   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82584   {
82585     try {
82586       (arg1)->Stop();
82587     } catch (std::out_of_range& e) {
82588       {
82589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82590       };
82591     } catch (std::exception& e) {
82592       {
82593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82594       };
82595     } catch (...) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82598       };
82599     }
82600   }
82601 }
82602
82603
82604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82605   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82606   int arg2 ;
82607
82608   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82609   arg2 = (int)jarg2;
82610   {
82611     try {
82612       (arg1)->Forward(arg2);
82613     } catch (std::out_of_range& e) {
82614       {
82615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82616       };
82617     } catch (std::exception& e) {
82618       {
82619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82620       };
82621     } catch (...) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82624       };
82625     }
82626   }
82627 }
82628
82629
82630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82631   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82632   int arg2 ;
82633
82634   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82635   arg2 = (int)jarg2;
82636   {
82637     try {
82638       (arg1)->Backward(arg2);
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (...) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82650       };
82651     }
82652   }
82653 }
82654
82655
82656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82657   void * jresult ;
82658   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82659   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82660
82661   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82662   {
82663     try {
82664       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82665     } catch (std::out_of_range& e) {
82666       {
82667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82668       };
82669     } catch (std::exception& e) {
82670       {
82671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82672       };
82673     } catch (...) {
82674       {
82675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82676       };
82677     }
82678   }
82679   jresult = (void *)result;
82680   return jresult;
82681 }
82682
82683
82684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82685   int jresult ;
82686   int result;
82687
82688   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82689   jresult = (int)result;
82690   return jresult;
82691 }
82692
82693
82694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82695   int jresult ;
82696   int result;
82697
82698   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82699   jresult = (int)result;
82700   return jresult;
82701 }
82702
82703
82704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82705   int jresult ;
82706   int result;
82707
82708   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82709   jresult = (int)result;
82710   return jresult;
82711 }
82712
82713
82714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82715   int jresult ;
82716   int result;
82717
82718   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82719   jresult = (int)result;
82720   return jresult;
82721 }
82722
82723
82724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82725   int jresult ;
82726   int result;
82727
82728   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82729   jresult = (int)result;
82730   return jresult;
82731 }
82732
82733
82734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82735   int jresult ;
82736   int result;
82737
82738   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82739   jresult = (int)result;
82740   return jresult;
82741 }
82742
82743
82744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82745   int jresult ;
82746   int result;
82747
82748   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82749   jresult = (int)result;
82750   return jresult;
82751 }
82752
82753
82754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82755   int jresult ;
82756   int result;
82757
82758   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82759   jresult = (int)result;
82760   return jresult;
82761 }
82762
82763
82764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82765   int jresult ;
82766   int result;
82767
82768   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82769   jresult = (int)result;
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82775   int jresult ;
82776   int result;
82777
82778   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82779   jresult = (int)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82785   int jresult ;
82786   int result;
82787
82788   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82789   jresult = (int)result;
82790   return jresult;
82791 }
82792
82793
82794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82795   int jresult ;
82796   int result;
82797
82798   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82799   jresult = (int)result;
82800   return jresult;
82801 }
82802
82803
82804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82805   int jresult ;
82806   int result;
82807
82808   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82809   jresult = (int)result;
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82815   int jresult ;
82816   int result;
82817
82818   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82819   jresult = (int)result;
82820   return jresult;
82821 }
82822
82823
82824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82825   int jresult ;
82826   int result;
82827
82828   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82829   jresult = (int)result;
82830   return jresult;
82831 }
82832
82833
82834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82835   int jresult ;
82836   int result;
82837
82838   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82839   jresult = (int)result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82845   int jresult ;
82846   int result;
82847
82848   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82849   jresult = (int)result;
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82855   int jresult ;
82856   int result;
82857
82858   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82859   jresult = (int)result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82865   int jresult ;
82866   int result;
82867
82868   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82869   jresult = (int)result;
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82875   int jresult ;
82876   int result;
82877
82878   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82879   jresult = (int)result;
82880   return jresult;
82881 }
82882
82883
82884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82885   int jresult ;
82886   int result;
82887
82888   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82889   jresult = (int)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82895   void * jresult ;
82896   Dali::Toolkit::Popup::Property *result = 0 ;
82897
82898   {
82899     try {
82900       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82901     } catch (std::out_of_range& e) {
82902       {
82903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82904       };
82905     } catch (std::exception& e) {
82906       {
82907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (...) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82912       };
82913     }
82914   }
82915   jresult = (void *)result;
82916   return jresult;
82917 }
82918
82919
82920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82921   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82922
82923   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82924   {
82925     try {
82926       delete arg1;
82927     } catch (std::out_of_range& e) {
82928       {
82929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82930       };
82931     } catch (std::exception& e) {
82932       {
82933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82934       };
82935     } catch (...) {
82936       {
82937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82938       };
82939     }
82940   }
82941 }
82942
82943
82944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82945   void * jresult ;
82946   Dali::Toolkit::Popup *result = 0 ;
82947
82948   {
82949     try {
82950       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
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_New() {
82971   void * jresult ;
82972   Dali::Toolkit::Popup result;
82973
82974   {
82975     try {
82976       result = Dali::Toolkit::Popup::New();
82977     } catch (std::out_of_range& e) {
82978       {
82979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82980       };
82981     } catch (std::exception& e) {
82982       {
82983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82984       };
82985     } catch (...) {
82986       {
82987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82988       };
82989     }
82990   }
82991   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82992   return jresult;
82993 }
82994
82995
82996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82997   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82998
82999   arg1 = (Dali::Toolkit::Popup *)jarg1;
83000   {
83001     try {
83002       delete arg1;
83003     } catch (std::out_of_range& e) {
83004       {
83005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (std::exception& e) {
83008       {
83009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83010       };
83011     } catch (...) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83014       };
83015     }
83016   }
83017 }
83018
83019
83020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83021   void * jresult ;
83022   Dali::Toolkit::Popup *arg1 = 0 ;
83023   Dali::Toolkit::Popup *result = 0 ;
83024
83025   arg1 = (Dali::Toolkit::Popup *)jarg1;
83026   if (!arg1) {
83027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83028     return 0;
83029   }
83030   {
83031     try {
83032       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83033     } catch (std::out_of_range& e) {
83034       {
83035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83036       };
83037     } catch (std::exception& e) {
83038       {
83039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83040       };
83041     } catch (...) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83044       };
83045     }
83046   }
83047   jresult = (void *)result;
83048   return jresult;
83049 }
83050
83051
83052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83053   void * jresult ;
83054   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83055   Dali::Toolkit::Popup *arg2 = 0 ;
83056   Dali::Toolkit::Popup *result = 0 ;
83057
83058   arg1 = (Dali::Toolkit::Popup *)jarg1;
83059   arg2 = (Dali::Toolkit::Popup *)jarg2;
83060   if (!arg2) {
83061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83062     return 0;
83063   }
83064   {
83065     try {
83066       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83067     } catch (std::out_of_range& e) {
83068       {
83069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83070       };
83071     } catch (std::exception& e) {
83072       {
83073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83074       };
83075     } catch (...) {
83076       {
83077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83078       };
83079     }
83080   }
83081   jresult = (void *)result;
83082   return jresult;
83083 }
83084
83085
83086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83087   void * jresult ;
83088   Dali::BaseHandle arg1 ;
83089   Dali::BaseHandle *argp1 ;
83090   Dali::Toolkit::Popup result;
83091
83092   argp1 = (Dali::BaseHandle *)jarg1;
83093   if (!argp1) {
83094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83095     return 0;
83096   }
83097   arg1 = *argp1;
83098   {
83099     try {
83100       result = Dali::Toolkit::Popup::DownCast(arg1);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83108       };
83109     } catch (...) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83112       };
83113     }
83114   }
83115   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83116   return jresult;
83117 }
83118
83119
83120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83121   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83122   Dali::Actor arg2 ;
83123   Dali::Actor *argp2 ;
83124
83125   arg1 = (Dali::Toolkit::Popup *)jarg1;
83126   argp2 = (Dali::Actor *)jarg2;
83127   if (!argp2) {
83128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83129     return ;
83130   }
83131   arg2 = *argp2;
83132   {
83133     try {
83134       (arg1)->SetTitle(arg2);
83135     } catch (std::out_of_range& e) {
83136       {
83137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83138       };
83139     } catch (std::exception& e) {
83140       {
83141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83142       };
83143     } catch (...) {
83144       {
83145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83146       };
83147     }
83148   }
83149 }
83150
83151
83152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83153   void * jresult ;
83154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83155   Dali::Actor result;
83156
83157   arg1 = (Dali::Toolkit::Popup *)jarg1;
83158   {
83159     try {
83160       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83161     } catch (std::out_of_range& e) {
83162       {
83163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (std::exception& e) {
83166       {
83167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (...) {
83170       {
83171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83172       };
83173     }
83174   }
83175   jresult = new Dali::Actor((const Dali::Actor &)result);
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83182   Dali::Actor arg2 ;
83183   Dali::Actor *argp2 ;
83184
83185   arg1 = (Dali::Toolkit::Popup *)jarg1;
83186   argp2 = (Dali::Actor *)jarg2;
83187   if (!argp2) {
83188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83189     return ;
83190   }
83191   arg2 = *argp2;
83192   {
83193     try {
83194       (arg1)->SetContent(arg2);
83195     } catch (std::out_of_range& e) {
83196       {
83197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83198       };
83199     } catch (std::exception& e) {
83200       {
83201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (...) {
83204       {
83205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83206       };
83207     }
83208   }
83209 }
83210
83211
83212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83213   void * jresult ;
83214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83215   Dali::Actor result;
83216
83217   arg1 = (Dali::Toolkit::Popup *)jarg1;
83218   {
83219     try {
83220       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83221     } catch (std::out_of_range& e) {
83222       {
83223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83224       };
83225     } catch (std::exception& e) {
83226       {
83227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (...) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83232       };
83233     }
83234   }
83235   jresult = new Dali::Actor((const Dali::Actor &)result);
83236   return jresult;
83237 }
83238
83239
83240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83241   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83242   Dali::Actor arg2 ;
83243   Dali::Actor *argp2 ;
83244
83245   arg1 = (Dali::Toolkit::Popup *)jarg1;
83246   argp2 = (Dali::Actor *)jarg2;
83247   if (!argp2) {
83248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83249     return ;
83250   }
83251   arg2 = *argp2;
83252   {
83253     try {
83254       (arg1)->SetFooter(arg2);
83255     } catch (std::out_of_range& e) {
83256       {
83257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83258       };
83259     } catch (std::exception& e) {
83260       {
83261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83266       };
83267     }
83268   }
83269 }
83270
83271
83272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83273   void * jresult ;
83274   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83275   Dali::Actor result;
83276
83277   arg1 = (Dali::Toolkit::Popup *)jarg1;
83278   {
83279     try {
83280       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83281     } catch (std::out_of_range& e) {
83282       {
83283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (std::exception& e) {
83286       {
83287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83292       };
83293     }
83294   }
83295   jresult = new Dali::Actor((const Dali::Actor &)result);
83296   return jresult;
83297 }
83298
83299
83300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83301   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83302   Dali::Toolkit::Popup::DisplayState arg2 ;
83303
83304   arg1 = (Dali::Toolkit::Popup *)jarg1;
83305   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83306   {
83307     try {
83308       (arg1)->SetDisplayState(arg2);
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83316       };
83317     } catch (...) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83320       };
83321     }
83322   }
83323 }
83324
83325
83326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83327   int jresult ;
83328   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83329   Dali::Toolkit::Popup::DisplayState result;
83330
83331   arg1 = (Dali::Toolkit::Popup *)jarg1;
83332   {
83333     try {
83334       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83335     } catch (std::out_of_range& e) {
83336       {
83337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83338       };
83339     } catch (std::exception& e) {
83340       {
83341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83342       };
83343     } catch (...) {
83344       {
83345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83346       };
83347     }
83348   }
83349   jresult = (int)result;
83350   return jresult;
83351 }
83352
83353
83354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83355   void * jresult ;
83356   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83357   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83358
83359   arg1 = (Dali::Toolkit::Popup *)jarg1;
83360   {
83361     try {
83362       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83363     } catch (std::out_of_range& e) {
83364       {
83365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83366       };
83367     } catch (std::exception& e) {
83368       {
83369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83370       };
83371     } catch (...) {
83372       {
83373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83374       };
83375     }
83376   }
83377   jresult = (void *)result;
83378   return jresult;
83379 }
83380
83381
83382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83383   void * jresult ;
83384   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83385   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83386
83387   arg1 = (Dali::Toolkit::Popup *)jarg1;
83388   {
83389     try {
83390       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83391     } catch (std::out_of_range& e) {
83392       {
83393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83394       };
83395     } catch (std::exception& e) {
83396       {
83397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83398       };
83399     } catch (...) {
83400       {
83401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83402       };
83403     }
83404   }
83405   jresult = (void *)result;
83406   return jresult;
83407 }
83408
83409
83410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83411   void * jresult ;
83412   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83413   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83414
83415   arg1 = (Dali::Toolkit::Popup *)jarg1;
83416   {
83417     try {
83418       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83419     } catch (std::out_of_range& e) {
83420       {
83421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83422       };
83423     } catch (std::exception& e) {
83424       {
83425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83426       };
83427     } catch (...) {
83428       {
83429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83430       };
83431     }
83432   }
83433   jresult = (void *)result;
83434   return jresult;
83435 }
83436
83437
83438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83439   void * jresult ;
83440   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83441   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83442
83443   arg1 = (Dali::Toolkit::Popup *)jarg1;
83444   {
83445     try {
83446       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83447     } catch (std::out_of_range& e) {
83448       {
83449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83450       };
83451     } catch (std::exception& e) {
83452       {
83453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83454       };
83455     } catch (...) {
83456       {
83457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83458       };
83459     }
83460   }
83461   jresult = (void *)result;
83462   return jresult;
83463 }
83464
83465
83466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83467   void * jresult ;
83468   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83469   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83470
83471   arg1 = (Dali::Toolkit::Popup *)jarg1;
83472   {
83473     try {
83474       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
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 int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83495   int jresult ;
83496   int result;
83497
83498   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83499   jresult = (int)result;
83500   return jresult;
83501 }
83502
83503
83504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83505   int jresult ;
83506   int result;
83507
83508   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83509   jresult = (int)result;
83510   return jresult;
83511 }
83512
83513
83514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83515   int jresult ;
83516   int result;
83517
83518   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83519   jresult = (int)result;
83520   return jresult;
83521 }
83522
83523
83524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83525   int jresult ;
83526   int result;
83527
83528   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83529   jresult = (int)result;
83530   return jresult;
83531 }
83532
83533
83534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83535   int jresult ;
83536   int result;
83537
83538   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83539   jresult = (int)result;
83540   return jresult;
83541 }
83542
83543
83544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83545   int jresult ;
83546   int result;
83547
83548   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83549   jresult = (int)result;
83550   return jresult;
83551 }
83552
83553
83554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83555   int jresult ;
83556   int result;
83557
83558   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83559   jresult = (int)result;
83560   return jresult;
83561 }
83562
83563
83564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83565   int jresult ;
83566   int result;
83567
83568   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83569   jresult = (int)result;
83570   return jresult;
83571 }
83572
83573
83574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83575   int jresult ;
83576   int result;
83577
83578   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83579   jresult = (int)result;
83580   return jresult;
83581 }
83582
83583
83584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83585   void * jresult ;
83586   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83587
83588   {
83589     try {
83590       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83591     } catch (std::out_of_range& e) {
83592       {
83593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (std::exception& e) {
83596       {
83597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (...) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83602       };
83603     }
83604   }
83605   jresult = (void *)result;
83606   return jresult;
83607 }
83608
83609
83610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83611   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83612
83613   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83614   {
83615     try {
83616       delete arg1;
83617     } catch (std::out_of_range& e) {
83618       {
83619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83620       };
83621     } catch (std::exception& e) {
83622       {
83623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83624       };
83625     } catch (...) {
83626       {
83627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83628       };
83629     }
83630   }
83631 }
83632
83633
83634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83635   void * jresult ;
83636   Dali::Toolkit::ProgressBar result;
83637
83638   {
83639     try {
83640       result = Dali::Toolkit::ProgressBar::New();
83641     } catch (std::out_of_range& e) {
83642       {
83643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83644       };
83645     } catch (std::exception& e) {
83646       {
83647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (...) {
83650       {
83651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83652       };
83653     }
83654   }
83655   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83656   return jresult;
83657 }
83658
83659
83660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83661   void * jresult ;
83662   Dali::Toolkit::ProgressBar *result = 0 ;
83663
83664   {
83665     try {
83666       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83667     } catch (std::out_of_range& e) {
83668       {
83669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83670       };
83671     } catch (std::exception& e) {
83672       {
83673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (...) {
83676       {
83677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83678       };
83679     }
83680   }
83681   jresult = (void *)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83687   void * jresult ;
83688   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83689   Dali::Toolkit::ProgressBar *result = 0 ;
83690
83691   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83692   if (!arg1) {
83693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83694     return 0;
83695   }
83696   {
83697     try {
83698       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83699     } catch (std::out_of_range& e) {
83700       {
83701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (std::exception& e) {
83704       {
83705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (...) {
83708       {
83709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83710       };
83711     }
83712   }
83713   jresult = (void *)result;
83714   return jresult;
83715 }
83716
83717
83718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83719   void * jresult ;
83720   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83721   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83722   Dali::Toolkit::ProgressBar *result = 0 ;
83723
83724   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83725   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83726   if (!arg2) {
83727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83728     return 0;
83729   }
83730   {
83731     try {
83732       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83733     } catch (std::out_of_range& e) {
83734       {
83735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83736       };
83737     } catch (std::exception& e) {
83738       {
83739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83740       };
83741     } catch (...) {
83742       {
83743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83744       };
83745     }
83746   }
83747   jresult = (void *)result;
83748   return jresult;
83749 }
83750
83751
83752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83753   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83754
83755   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83756   {
83757     try {
83758       delete arg1;
83759     } catch (std::out_of_range& e) {
83760       {
83761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83762       };
83763     } catch (std::exception& e) {
83764       {
83765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83766       };
83767     } catch (...) {
83768       {
83769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83770       };
83771     }
83772   }
83773 }
83774
83775
83776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83777   void * jresult ;
83778   Dali::BaseHandle arg1 ;
83779   Dali::BaseHandle *argp1 ;
83780   Dali::Toolkit::ProgressBar result;
83781
83782   argp1 = (Dali::BaseHandle *)jarg1;
83783   if (!argp1) {
83784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83785     return 0;
83786   }
83787   arg1 = *argp1;
83788   {
83789     try {
83790       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (...) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83802       };
83803     }
83804   }
83805   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83806   return jresult;
83807 }
83808
83809
83810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83811   void * jresult ;
83812   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83813   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83814
83815   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83816   {
83817     try {
83818       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83819     } catch (std::out_of_range& e) {
83820       {
83821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83822       };
83823     } catch (std::exception& e) {
83824       {
83825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (...) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83830       };
83831     }
83832   }
83833   jresult = (void *)result;
83834   return jresult;
83835 }
83836
83837
83838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83839   void * jresult ;
83840   Dali::Toolkit::GaussianBlurView *result = 0 ;
83841
83842   {
83843     try {
83844       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83856       };
83857     }
83858   }
83859   jresult = (void *)result;
83860   return jresult;
83861 }
83862
83863
83864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83865   void * jresult ;
83866   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83867   Dali::Toolkit::GaussianBlurView *result = 0 ;
83868
83869   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83870   if (!arg1) {
83871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83872     return 0;
83873   }
83874   {
83875     try {
83876       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83877     } catch (std::out_of_range& e) {
83878       {
83879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83880       };
83881     } catch (std::exception& e) {
83882       {
83883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83884       };
83885     } catch (...) {
83886       {
83887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83888       };
83889     }
83890   }
83891   jresult = (void *)result;
83892   return jresult;
83893 }
83894
83895
83896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83897   void * jresult ;
83898   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83899   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83900   Dali::Toolkit::GaussianBlurView *result = 0 ;
83901
83902   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83903   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83904   if (!arg2) {
83905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83906     return 0;
83907   }
83908   {
83909     try {
83910       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83911     } catch (std::out_of_range& e) {
83912       {
83913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83914       };
83915     } catch (std::exception& e) {
83916       {
83917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83918       };
83919     } catch (...) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83922       };
83923     }
83924   }
83925   jresult = (void *)result;
83926   return jresult;
83927 }
83928
83929
83930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83931   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83932
83933   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83934   {
83935     try {
83936       delete arg1;
83937     } catch (std::out_of_range& e) {
83938       {
83939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83940       };
83941     } catch (std::exception& e) {
83942       {
83943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83948       };
83949     }
83950   }
83951 }
83952
83953
83954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83955   void * jresult ;
83956   Dali::BaseHandle arg1 ;
83957   Dali::BaseHandle *argp1 ;
83958   Dali::Toolkit::GaussianBlurView result;
83959
83960   argp1 = (Dali::BaseHandle *)jarg1;
83961   if (!argp1) {
83962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83963     return 0;
83964   }
83965   arg1 = *argp1;
83966   {
83967     try {
83968       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83969     } catch (std::out_of_range& e) {
83970       {
83971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83972       };
83973     } catch (std::exception& e) {
83974       {
83975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83976       };
83977     } catch (...) {
83978       {
83979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83980       };
83981     }
83982   }
83983   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83984   return jresult;
83985 }
83986
83987
83988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83989   void * jresult ;
83990   Dali::Toolkit::GaussianBlurView result;
83991
83992   {
83993     try {
83994       result = Dali::Toolkit::GaussianBlurView::New();
83995     } catch (std::out_of_range& e) {
83996       {
83997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83998       };
83999     } catch (std::exception& e) {
84000       {
84001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84002       };
84003     } catch (...) {
84004       {
84005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84006       };
84007     }
84008   }
84009   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84010   return jresult;
84011 }
84012
84013
84014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84015   void * jresult ;
84016   unsigned int arg1 ;
84017   float arg2 ;
84018   Dali::Pixel::Format arg3 ;
84019   float arg4 ;
84020   float arg5 ;
84021   bool arg6 ;
84022   Dali::Toolkit::GaussianBlurView result;
84023
84024   arg1 = (unsigned int)jarg1;
84025   arg2 = (float)jarg2;
84026   arg3 = (Dali::Pixel::Format)jarg3;
84027   arg4 = (float)jarg4;
84028   arg5 = (float)jarg5;
84029   arg6 = jarg6 ? true : false;
84030   {
84031     try {
84032       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84033     } catch (std::out_of_range& e) {
84034       {
84035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (std::exception& e) {
84038       {
84039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84040       };
84041     } catch (...) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84044       };
84045     }
84046   }
84047   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84053   void * jresult ;
84054   unsigned int arg1 ;
84055   float arg2 ;
84056   Dali::Pixel::Format arg3 ;
84057   float arg4 ;
84058   float arg5 ;
84059   Dali::Toolkit::GaussianBlurView result;
84060
84061   arg1 = (unsigned int)jarg1;
84062   arg2 = (float)jarg2;
84063   arg3 = (Dali::Pixel::Format)jarg3;
84064   arg4 = (float)jarg4;
84065   arg5 = (float)jarg5;
84066   {
84067     try {
84068       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84069     } catch (std::out_of_range& e) {
84070       {
84071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84072       };
84073     } catch (std::exception& e) {
84074       {
84075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84076       };
84077     } catch (...) {
84078       {
84079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84080       };
84081     }
84082   }
84083   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84084   return jresult;
84085 }
84086
84087
84088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84089   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84090   Dali::Actor arg2 ;
84091   Dali::Actor *argp2 ;
84092
84093   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84094   argp2 = (Dali::Actor *)jarg2;
84095   if (!argp2) {
84096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84097     return ;
84098   }
84099   arg2 = *argp2;
84100   {
84101     try {
84102       (arg1)->Add(arg2);
84103     } catch (std::out_of_range& e) {
84104       {
84105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84106       };
84107     } catch (std::exception& e) {
84108       {
84109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84110       };
84111     } catch (...) {
84112       {
84113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84114       };
84115     }
84116   }
84117 }
84118
84119
84120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84121   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84122   Dali::Actor arg2 ;
84123   Dali::Actor *argp2 ;
84124
84125   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84126   argp2 = (Dali::Actor *)jarg2;
84127   if (!argp2) {
84128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84129     return ;
84130   }
84131   arg2 = *argp2;
84132   {
84133     try {
84134       (arg1)->Remove(arg2);
84135     } catch (std::out_of_range& e) {
84136       {
84137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (std::exception& e) {
84140       {
84141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84146       };
84147     }
84148   }
84149 }
84150
84151
84152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84153   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84154
84155   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84156   {
84157     try {
84158       (arg1)->Activate();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84166       };
84167     } catch (...) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84170       };
84171     }
84172   }
84173 }
84174
84175
84176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84177   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84178
84179   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84180   {
84181     try {
84182       (arg1)->ActivateOnce();
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84190       };
84191     } catch (...) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84194       };
84195     }
84196   }
84197 }
84198
84199
84200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84201   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84202
84203   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84204   {
84205     try {
84206       (arg1)->Deactivate();
84207     } catch (std::out_of_range& e) {
84208       {
84209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84210       };
84211     } catch (std::exception& e) {
84212       {
84213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84214       };
84215     } catch (...) {
84216       {
84217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84218       };
84219     }
84220   }
84221 }
84222
84223
84224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84225   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84226   Dali::Image arg2 ;
84227   Dali::FrameBufferImage arg3 ;
84228   Dali::Image *argp2 ;
84229   Dali::FrameBufferImage *argp3 ;
84230
84231   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84232   argp2 = (Dali::Image *)jarg2;
84233   if (!argp2) {
84234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84235     return ;
84236   }
84237   arg2 = *argp2;
84238   argp3 = (Dali::FrameBufferImage *)jarg3;
84239   if (!argp3) {
84240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84241     return ;
84242   }
84243   arg3 = *argp3;
84244   {
84245     try {
84246       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84247     } catch (std::out_of_range& e) {
84248       {
84249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84250       };
84251     } catch (std::exception& e) {
84252       {
84253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84254       };
84255     } catch (...) {
84256       {
84257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84258       };
84259     }
84260   }
84261 }
84262
84263
84264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84265   int jresult ;
84266   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84267   Dali::Property::Index result;
84268
84269   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84270   {
84271     try {
84272       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84273     } catch (std::out_of_range& e) {
84274       {
84275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84276       };
84277     } catch (std::exception& e) {
84278       {
84279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84280       };
84281     } catch (...) {
84282       {
84283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84284       };
84285     }
84286   }
84287   jresult = result;
84288   return jresult;
84289 }
84290
84291
84292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84293   void * jresult ;
84294   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84295   Dali::FrameBufferImage result;
84296
84297   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84298   {
84299     try {
84300       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84301     } catch (std::out_of_range& e) {
84302       {
84303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84304       };
84305     } catch (std::exception& e) {
84306       {
84307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84308       };
84309     } catch (...) {
84310       {
84311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84312       };
84313     }
84314   }
84315   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84316   return jresult;
84317 }
84318
84319
84320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84321   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84322   Dali::Vector4 *arg2 = 0 ;
84323
84324   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84325   arg2 = (Dali::Vector4 *)jarg2;
84326   if (!arg2) {
84327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84328     return ;
84329   }
84330   {
84331     try {
84332       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84333     } catch (std::out_of_range& e) {
84334       {
84335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84336       };
84337     } catch (std::exception& e) {
84338       {
84339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84340       };
84341     } catch (...) {
84342       {
84343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84344       };
84345     }
84346   }
84347 }
84348
84349
84350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84351   void * jresult ;
84352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84353   Dali::Vector4 result;
84354
84355   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84356   {
84357     try {
84358       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84359     } catch (std::out_of_range& e) {
84360       {
84361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84362       };
84363     } catch (std::exception& e) {
84364       {
84365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84366       };
84367     } catch (...) {
84368       {
84369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84370       };
84371     }
84372   }
84373   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84374   return jresult;
84375 }
84376
84377
84378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84379   void * jresult ;
84380   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84381   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84382
84383   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84384   {
84385     try {
84386       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84387     } catch (std::out_of_range& e) {
84388       {
84389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84390       };
84391     } catch (std::exception& e) {
84392       {
84393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84394       };
84395     } catch (...) {
84396       {
84397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84398       };
84399     }
84400   }
84401   jresult = (void *)result;
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84407   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84408
84409   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84410   {
84411     try {
84412       delete arg1;
84413     } catch (std::out_of_range& e) {
84414       {
84415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84416       };
84417     } catch (std::exception& e) {
84418       {
84419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84420       };
84421     } catch (...) {
84422       {
84423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84424       };
84425     }
84426   }
84427 }
84428
84429
84430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84431   unsigned int jresult ;
84432   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84433   unsigned int result;
84434
84435   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84436   {
84437     try {
84438       result = (unsigned int)(arg1)->GetNumberOfPages();
84439     } catch (std::out_of_range& e) {
84440       {
84441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (std::exception& e) {
84444       {
84445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84446       };
84447     } catch (...) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84450       };
84451     }
84452   }
84453   jresult = result;
84454   return jresult;
84455 }
84456
84457
84458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84459   void * jresult ;
84460   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84461   unsigned int arg2 ;
84462   Dali::Texture result;
84463
84464   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84465   arg2 = (unsigned int)jarg2;
84466   {
84467     try {
84468       result = (arg1)->NewPage(arg2);
84469     } catch (std::out_of_range& e) {
84470       {
84471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (std::exception& e) {
84474       {
84475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (...) {
84478       {
84479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84480       };
84481     }
84482   }
84483   jresult = new Dali::Texture((const Dali::Texture &)result);
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84489   int jresult ;
84490   int result;
84491
84492   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84493   jresult = (int)result;
84494   return jresult;
84495 }
84496
84497
84498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84499   int jresult ;
84500   int result;
84501
84502   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84503   jresult = (int)result;
84504   return jresult;
84505 }
84506
84507
84508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84509   int jresult ;
84510   int result;
84511
84512   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84513   jresult = (int)result;
84514   return jresult;
84515 }
84516
84517
84518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84519   void * jresult ;
84520   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84521
84522   {
84523     try {
84524       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
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_Property(void * jarg1) {
84545   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84546
84547   arg1 = (Dali::Toolkit::PageTurnView::Property *)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_new_PageTurnView__SWIG_0() {
84569   void * jresult ;
84570   Dali::Toolkit::PageTurnView *result = 0 ;
84571
84572   {
84573     try {
84574       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84575     } catch (std::out_of_range& e) {
84576       {
84577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84578       };
84579     } catch (std::exception& e) {
84580       {
84581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84586       };
84587     }
84588   }
84589   jresult = (void *)result;
84590   return jresult;
84591 }
84592
84593
84594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84595   void * jresult ;
84596   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84597   Dali::Toolkit::PageTurnView *result = 0 ;
84598
84599   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84600   if (!arg1) {
84601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84602     return 0;
84603   }
84604   {
84605     try {
84606       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84607     } catch (std::out_of_range& e) {
84608       {
84609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84610       };
84611     } catch (std::exception& e) {
84612       {
84613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84614       };
84615     } catch (...) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84618       };
84619     }
84620   }
84621   jresult = (void *)result;
84622   return jresult;
84623 }
84624
84625
84626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84627   void * jresult ;
84628   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84629   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84630   Dali::Toolkit::PageTurnView *result = 0 ;
84631
84632   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84633   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84634   if (!arg2) {
84635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84636     return 0;
84637   }
84638   {
84639     try {
84640       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84641     } catch (std::out_of_range& e) {
84642       {
84643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (std::exception& e) {
84646       {
84647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655   jresult = (void *)result;
84656   return jresult;
84657 }
84658
84659
84660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84661   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84662
84663   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84664   {
84665     try {
84666       delete arg1;
84667     } catch (std::out_of_range& e) {
84668       {
84669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84670       };
84671     } catch (std::exception& e) {
84672       {
84673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84674       };
84675     } catch (...) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84678       };
84679     }
84680   }
84681 }
84682
84683
84684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84685   void * jresult ;
84686   Dali::BaseHandle arg1 ;
84687   Dali::BaseHandle *argp1 ;
84688   Dali::Toolkit::PageTurnView result;
84689
84690   argp1 = (Dali::BaseHandle *)jarg1;
84691   if (!argp1) {
84692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84693     return 0;
84694   }
84695   arg1 = *argp1;
84696   {
84697     try {
84698       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84699     } catch (std::out_of_range& e) {
84700       {
84701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (std::exception& e) {
84704       {
84705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (...) {
84708       {
84709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84710       };
84711     }
84712   }
84713   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84714   return jresult;
84715 }
84716
84717
84718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84719   void * jresult ;
84720   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84721   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84722
84723   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84724   {
84725     try {
84726       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84727     } catch (std::out_of_range& e) {
84728       {
84729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84730       };
84731     } catch (std::exception& e) {
84732       {
84733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84734       };
84735     } catch (...) {
84736       {
84737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84738       };
84739     }
84740   }
84741   jresult = (void *)result;
84742   return jresult;
84743 }
84744
84745
84746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84747   void * jresult ;
84748   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84749   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84750
84751   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84752   {
84753     try {
84754       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84755     } catch (std::out_of_range& e) {
84756       {
84757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (std::exception& e) {
84760       {
84761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84762       };
84763     } catch (...) {
84764       {
84765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84766       };
84767     }
84768   }
84769   jresult = (void *)result;
84770   return jresult;
84771 }
84772
84773
84774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84775   void * jresult ;
84776   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84777   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84778
84779   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84780   {
84781     try {
84782       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84783     } catch (std::out_of_range& e) {
84784       {
84785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84786       };
84787     } catch (std::exception& e) {
84788       {
84789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (...) {
84792       {
84793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84794       };
84795     }
84796   }
84797   jresult = (void *)result;
84798   return jresult;
84799 }
84800
84801
84802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84803   void * jresult ;
84804   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84805   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84806
84807   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84808   {
84809     try {
84810       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (...) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84822       };
84823     }
84824   }
84825   jresult = (void *)result;
84826   return jresult;
84827 }
84828
84829
84830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84831   void * jresult ;
84832   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84833
84834   {
84835     try {
84836       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84837     } catch (std::out_of_range& e) {
84838       {
84839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (std::exception& e) {
84842       {
84843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84844       };
84845     } catch (...) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84848       };
84849     }
84850   }
84851   jresult = (void *)result;
84852   return jresult;
84853 }
84854
84855
84856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84857   void * jresult ;
84858   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84859   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84860
84861   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84862   if (!arg1) {
84863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84864     return 0;
84865   }
84866   {
84867     try {
84868       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84869     } catch (std::out_of_range& e) {
84870       {
84871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84872       };
84873     } catch (std::exception& e) {
84874       {
84875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84876       };
84877     } catch (...) {
84878       {
84879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84880       };
84881     }
84882   }
84883   jresult = (void *)result;
84884   return jresult;
84885 }
84886
84887
84888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84889   void * jresult ;
84890   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84891   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84892   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84893
84894   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84895   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84896   if (!arg2) {
84897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84898     return 0;
84899   }
84900   {
84901     try {
84902       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84903     } catch (std::out_of_range& e) {
84904       {
84905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84906       };
84907     } catch (std::exception& e) {
84908       {
84909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (...) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84914       };
84915     }
84916   }
84917   jresult = (void *)result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84923   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84924
84925   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84926   {
84927     try {
84928       delete arg1;
84929     } catch (std::out_of_range& e) {
84930       {
84931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84932       };
84933     } catch (std::exception& e) {
84934       {
84935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84936       };
84937     } catch (...) {
84938       {
84939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84940       };
84941     }
84942   }
84943 }
84944
84945
84946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84947   void * jresult ;
84948   Dali::Toolkit::PageFactory *arg1 = 0 ;
84949   Dali::Vector2 *arg2 = 0 ;
84950   Dali::Toolkit::PageTurnLandscapeView result;
84951
84952   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84953   if (!arg1) {
84954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84955     return 0;
84956   }
84957   arg2 = (Dali::Vector2 *)jarg2;
84958   if (!arg2) {
84959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84960     return 0;
84961   }
84962   {
84963     try {
84964       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84965     } catch (std::out_of_range& e) {
84966       {
84967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84968       };
84969     } catch (std::exception& e) {
84970       {
84971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84972       };
84973     } catch (...) {
84974       {
84975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84976       };
84977     }
84978   }
84979   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84980   return jresult;
84981 }
84982
84983
84984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84985   void * jresult ;
84986   Dali::BaseHandle arg1 ;
84987   Dali::BaseHandle *argp1 ;
84988   Dali::Toolkit::PageTurnLandscapeView result;
84989
84990   argp1 = (Dali::BaseHandle *)jarg1;
84991   if (!argp1) {
84992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84993     return 0;
84994   }
84995   arg1 = *argp1;
84996   {
84997     try {
84998       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84999     } catch (std::out_of_range& e) {
85000       {
85001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85002       };
85003     } catch (std::exception& e) {
85004       {
85005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85006       };
85007     } catch (...) {
85008       {
85009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85010       };
85011     }
85012   }
85013   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85014   return jresult;
85015 }
85016
85017
85018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85019   void * jresult ;
85020   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85021
85022   {
85023     try {
85024       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85025     } catch (std::out_of_range& e) {
85026       {
85027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85028       };
85029     } catch (std::exception& e) {
85030       {
85031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85032       };
85033     } catch (...) {
85034       {
85035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85036       };
85037     }
85038   }
85039   jresult = (void *)result;
85040   return jresult;
85041 }
85042
85043
85044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85045   void * jresult ;
85046   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85047   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85048
85049   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85050   if (!arg1) {
85051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85052     return 0;
85053   }
85054   {
85055     try {
85056       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (...) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85068       };
85069     }
85070   }
85071   jresult = (void *)result;
85072   return jresult;
85073 }
85074
85075
85076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85077   void * jresult ;
85078   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85079   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85080   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85081
85082   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85083   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85084   if (!arg2) {
85085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85086     return 0;
85087   }
85088   {
85089     try {
85090       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85091     } catch (std::out_of_range& e) {
85092       {
85093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (std::exception& e) {
85096       {
85097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (...) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85102       };
85103     }
85104   }
85105   jresult = (void *)result;
85106   return jresult;
85107 }
85108
85109
85110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85111   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85112
85113   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85114   {
85115     try {
85116       delete arg1;
85117     } catch (std::out_of_range& e) {
85118       {
85119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85120       };
85121     } catch (std::exception& e) {
85122       {
85123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85124       };
85125     } catch (...) {
85126       {
85127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85128       };
85129     }
85130   }
85131 }
85132
85133
85134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85135   void * jresult ;
85136   Dali::Toolkit::PageFactory *arg1 = 0 ;
85137   Dali::Vector2 *arg2 = 0 ;
85138   Dali::Toolkit::PageTurnPortraitView result;
85139
85140   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85141   if (!arg1) {
85142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85143     return 0;
85144   }
85145   arg2 = (Dali::Vector2 *)jarg2;
85146   if (!arg2) {
85147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85148     return 0;
85149   }
85150   {
85151     try {
85152       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85153     } catch (std::out_of_range& e) {
85154       {
85155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85156       };
85157     } catch (std::exception& e) {
85158       {
85159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85164       };
85165     }
85166   }
85167   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85168   return jresult;
85169 }
85170
85171
85172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85173   void * jresult ;
85174   Dali::BaseHandle arg1 ;
85175   Dali::BaseHandle *argp1 ;
85176   Dali::Toolkit::PageTurnPortraitView result;
85177
85178   argp1 = (Dali::BaseHandle *)jarg1;
85179   if (!argp1) {
85180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85181     return 0;
85182   }
85183   arg1 = *argp1;
85184   {
85185     try {
85186       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85187     } catch (std::out_of_range& e) {
85188       {
85189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (std::exception& e) {
85192       {
85193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85194       };
85195     } catch (...) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85198       };
85199     }
85200   }
85201   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85202   return jresult;
85203 }
85204
85205
85206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85207   int jresult ;
85208   int result;
85209
85210   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85211   jresult = (int)result;
85212   return jresult;
85213 }
85214
85215
85216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85217   int jresult ;
85218   int result;
85219
85220   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85221   jresult = (int)result;
85222   return jresult;
85223 }
85224
85225
85226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85227   int jresult ;
85228   int result;
85229
85230   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85231   jresult = (int)result;
85232   return jresult;
85233 }
85234
85235
85236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85237   void * jresult ;
85238   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85239
85240   {
85241     try {
85242       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
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_Property(void * jarg1) {
85263   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85264
85265   arg1 = (Dali::Toolkit::ToggleButton::Property *)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_new_ToggleButton__SWIG_0() {
85287   void * jresult ;
85288   Dali::Toolkit::ToggleButton *result = 0 ;
85289
85290   {
85291     try {
85292       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
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 = (void *)result;
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85313   void * jresult ;
85314   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85315   Dali::Toolkit::ToggleButton *result = 0 ;
85316
85317   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85318   if (!arg1) {
85319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85320     return 0;
85321   }
85322   {
85323     try {
85324       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85325     } catch (std::out_of_range& e) {
85326       {
85327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85328       };
85329     } catch (std::exception& e) {
85330       {
85331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (...) {
85334       {
85335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85336       };
85337     }
85338   }
85339   jresult = (void *)result;
85340   return jresult;
85341 }
85342
85343
85344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85345   void * jresult ;
85346   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85347   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85348   Dali::Toolkit::ToggleButton *result = 0 ;
85349
85350   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85351   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85352   if (!arg2) {
85353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85354     return 0;
85355   }
85356   {
85357     try {
85358       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85359     } catch (std::out_of_range& e) {
85360       {
85361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85362       };
85363     } catch (std::exception& e) {
85364       {
85365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85366       };
85367     } catch (...) {
85368       {
85369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85370       };
85371     }
85372   }
85373   jresult = (void *)result;
85374   return jresult;
85375 }
85376
85377
85378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85379   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85380
85381   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85382   {
85383     try {
85384       delete arg1;
85385     } catch (std::out_of_range& e) {
85386       {
85387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85388       };
85389     } catch (std::exception& e) {
85390       {
85391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85392       };
85393     } catch (...) {
85394       {
85395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85396       };
85397     }
85398   }
85399 }
85400
85401
85402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85403   void * jresult ;
85404   Dali::Toolkit::ToggleButton result;
85405
85406   {
85407     try {
85408       result = Dali::Toolkit::ToggleButton::New();
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 = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85424   return jresult;
85425 }
85426
85427
85428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85429   void * jresult ;
85430   Dali::BaseHandle arg1 ;
85431   Dali::BaseHandle *argp1 ;
85432   Dali::Toolkit::ToggleButton result;
85433
85434   argp1 = (Dali::BaseHandle *)jarg1;
85435   if (!argp1) {
85436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85437     return 0;
85438   }
85439   arg1 = *argp1;
85440   {
85441     try {
85442       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
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 = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85458   return jresult;
85459 }
85460
85461
85462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85463   void * jresult ;
85464   Dali::Toolkit::Visual::Base *result = 0 ;
85465
85466   {
85467     try {
85468       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85469     } catch (std::out_of_range& e) {
85470       {
85471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (std::exception& e) {
85474       {
85475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (...) {
85478       {
85479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85480       };
85481     }
85482   }
85483   jresult = (void *)result;
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85489   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85490
85491   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85492   {
85493     try {
85494       delete arg1;
85495     } catch (std::out_of_range& e) {
85496       {
85497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85498       };
85499     } catch (std::exception& e) {
85500       {
85501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85502       };
85503     } catch (...) {
85504       {
85505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85506       };
85507     }
85508   }
85509 }
85510
85511
85512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85513   void * jresult ;
85514   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85515   Dali::Toolkit::Visual::Base *result = 0 ;
85516
85517   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85518   if (!arg1) {
85519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85520     return 0;
85521   }
85522   {
85523     try {
85524       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85525     } catch (std::out_of_range& e) {
85526       {
85527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85528       };
85529     } catch (std::exception& e) {
85530       {
85531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85532       };
85533     } catch (...) {
85534       {
85535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85536       };
85537     }
85538   }
85539   jresult = (void *)result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85545   void * jresult ;
85546   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85547   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85548   Dali::Toolkit::Visual::Base *result = 0 ;
85549
85550   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85551   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85552   if (!arg2) {
85553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85554     return 0;
85555   }
85556   {
85557     try {
85558       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85559     } catch (std::out_of_range& e) {
85560       {
85561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85562       };
85563     } catch (std::exception& e) {
85564       {
85565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85566       };
85567     } catch (...) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85570       };
85571     }
85572   }
85573   jresult = (void *)result;
85574   return jresult;
85575 }
85576
85577
85578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85579   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85580   std::string *arg2 = 0 ;
85581
85582   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85583   if (!jarg2) {
85584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85585     return ;
85586   }
85587   std::string arg2_str(jarg2);
85588   arg2 = &arg2_str;
85589   {
85590     try {
85591       (arg1)->SetName((std::string const &)*arg2);
85592     } catch (std::out_of_range& e) {
85593       {
85594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85595       };
85596     } catch (std::exception& e) {
85597       {
85598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85599       };
85600     } catch (...) {
85601       {
85602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85603       };
85604     }
85605   }
85606
85607   //argout typemap for const std::string&
85608
85609 }
85610
85611
85612 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85613   char * jresult ;
85614   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85615   std::string *result = 0 ;
85616
85617   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85618   {
85619     try {
85620       result = (std::string *) &(arg1)->GetName();
85621     } catch (std::out_of_range& e) {
85622       {
85623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85624       };
85625     } catch (std::exception& e) {
85626       {
85627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85628       };
85629     } catch (...) {
85630       {
85631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85632       };
85633     }
85634   }
85635   jresult = SWIG_csharp_string_callback(result->c_str());
85636   return jresult;
85637 }
85638
85639
85640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85641   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85642   Dali::Property::Map *arg2 = 0 ;
85643   Dali::Size arg3 ;
85644   Dali::Size *argp3 ;
85645
85646   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85647   arg2 = (Dali::Property::Map *)jarg2;
85648   if (!arg2) {
85649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85650     return ;
85651   }
85652   argp3 = (Dali::Size *)jarg3;
85653   if (!argp3) {
85654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85655     return ;
85656   }
85657   arg3 = *argp3;
85658   {
85659     try {
85660       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
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_GetHeightForWidth(void * jarg1, float jarg2) {
85679   float jresult ;
85680   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85681   float arg2 ;
85682   float result;
85683
85684   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85685   arg2 = (float)jarg2;
85686   {
85687     try {
85688       result = (float)(arg1)->GetHeightForWidth(arg2);
85689     } catch (std::out_of_range& e) {
85690       {
85691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85692       };
85693     } catch (std::exception& e) {
85694       {
85695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85696       };
85697     } catch (...) {
85698       {
85699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85700       };
85701     }
85702   }
85703   jresult = result;
85704   return jresult;
85705 }
85706
85707
85708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85709   float jresult ;
85710   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85711   float arg2 ;
85712   float result;
85713
85714   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85715   arg2 = (float)jarg2;
85716   {
85717     try {
85718       result = (float)(arg1)->GetWidthForHeight(arg2);
85719     } catch (std::out_of_range& e) {
85720       {
85721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85722       };
85723     } catch (std::exception& e) {
85724       {
85725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (...) {
85728       {
85729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85730       };
85731     }
85732   }
85733   jresult = result;
85734   return jresult;
85735 }
85736
85737
85738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85739   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85740   Dali::Vector2 *arg2 = 0 ;
85741
85742   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85743   arg2 = (Dali::Vector2 *)jarg2;
85744   if (!arg2) {
85745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85746     return ;
85747   }
85748   {
85749     try {
85750       (arg1)->GetNaturalSize(*arg2);
85751     } catch (std::out_of_range& e) {
85752       {
85753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85754       };
85755     } catch (std::exception& e) {
85756       {
85757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85758       };
85759     } catch (...) {
85760       {
85761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85762       };
85763     }
85764   }
85765 }
85766
85767
85768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85769   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85770   float arg2 ;
85771
85772   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85773   arg2 = (int)jarg2;
85774   {
85775     try {
85776       (arg1)->SetDepthIndex(arg2);
85777     } catch (std::out_of_range& e) {
85778       {
85779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85780       };
85781     } catch (std::exception& e) {
85782       {
85783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85784       };
85785     } catch (...) {
85786       {
85787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85788       };
85789     }
85790   }
85791 }
85792
85793
85794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85795   int jresult ;
85796   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85797   int result;
85798
85799   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85800   {
85801     try {
85802       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (...) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85814       };
85815     }
85816   }
85817   jresult = result;
85818   return jresult;
85819 }
85820
85821
85822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85823   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85824   Dali::Property::Map *arg2 = 0 ;
85825
85826   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85827   arg2 = (Dali::Property::Map *)jarg2;
85828   if (!arg2) {
85829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85830     return ;
85831   }
85832   {
85833     try {
85834       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85842       };
85843     } catch (...) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85846       };
85847     }
85848   }
85849 }
85850
85851
85852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85853   void * jresult ;
85854   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85855   Dali::Toolkit::Visual::Base *result = 0 ;
85856
85857   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85858   {
85859     try {
85860       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875   jresult = (void *)result;
85876   return jresult;
85877 }
85878
85879
85880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85881   void * jresult ;
85882   Dali::Toolkit::VisualFactory result;
85883
85884   {
85885     try {
85886       result = Dali::Toolkit::VisualFactory::Get();
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 = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85902   return jresult;
85903 }
85904
85905
85906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85907   void * jresult ;
85908   Dali::Toolkit::VisualFactory *result = 0 ;
85909
85910   {
85911     try {
85912       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85913     } catch (std::out_of_range& e) {
85914       {
85915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85916       };
85917     } catch (std::exception& e) {
85918       {
85919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85920       };
85921     } catch (...) {
85922       {
85923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85924       };
85925     }
85926   }
85927   jresult = (void *)result;
85928   return jresult;
85929 }
85930
85931
85932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85933   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85934
85935   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85936   {
85937     try {
85938       delete arg1;
85939     } catch (std::out_of_range& e) {
85940       {
85941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85942       };
85943     } catch (std::exception& e) {
85944       {
85945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85946       };
85947     } catch (...) {
85948       {
85949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85950       };
85951     }
85952   }
85953 }
85954
85955
85956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85957   void * jresult ;
85958   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85959   Dali::Toolkit::VisualFactory *result = 0 ;
85960
85961   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85962   if (!arg1) {
85963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85964     return 0;
85965   }
85966   {
85967     try {
85968       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85969     } catch (std::out_of_range& e) {
85970       {
85971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85972       };
85973     } catch (std::exception& e) {
85974       {
85975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85980       };
85981     }
85982   }
85983   jresult = (void *)result;
85984   return jresult;
85985 }
85986
85987
85988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85989   void * jresult ;
85990   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85991   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85992   Dali::Toolkit::VisualFactory *result = 0 ;
85993
85994   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85995   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85996   if (!arg2) {
85997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85998     return 0;
85999   }
86000   {
86001     try {
86002       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86003     } catch (std::out_of_range& e) {
86004       {
86005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86006       };
86007     } catch (std::exception& e) {
86008       {
86009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86010       };
86011     } catch (...) {
86012       {
86013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86014       };
86015     }
86016   }
86017   jresult = (void *)result;
86018   return jresult;
86019 }
86020
86021
86022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86023   void * jresult ;
86024   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86025   Dali::Property::Map *arg2 = 0 ;
86026   Dali::Toolkit::Visual::Base result;
86027
86028   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86029   arg2 = (Dali::Property::Map *)jarg2;
86030   if (!arg2) {
86031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86032     return 0;
86033   }
86034   {
86035     try {
86036       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86037     } catch (std::out_of_range& e) {
86038       {
86039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86040       };
86041     } catch (std::exception& e) {
86042       {
86043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86044       };
86045     } catch (...) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86048       };
86049     }
86050   }
86051   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86052   return jresult;
86053 }
86054
86055
86056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
86057   void * jresult ;
86058   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86059   Dali::Image *arg2 = 0 ;
86060   Dali::Toolkit::Visual::Base result;
86061
86062   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86063   arg2 = (Dali::Image *)jarg2;
86064   if (!arg2) {
86065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
86066     return 0;
86067   }
86068   {
86069     try {
86070       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
86071     } catch (std::out_of_range& e) {
86072       {
86073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (std::exception& e) {
86076       {
86077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86086   return jresult;
86087 }
86088
86089
86090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86091   void * jresult ;
86092   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86093   std::string *arg2 = 0 ;
86094   Dali::ImageDimensions arg3 ;
86095   Dali::ImageDimensions *argp3 ;
86096   Dali::Toolkit::Visual::Base result;
86097
86098   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86099   if (!jarg2) {
86100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86101     return 0;
86102   }
86103   std::string arg2_str(jarg2);
86104   arg2 = &arg2_str;
86105   argp3 = (Dali::ImageDimensions *)jarg3;
86106   if (!argp3) {
86107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86108     return 0;
86109   }
86110   arg3 = *argp3;
86111   {
86112     try {
86113       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86114     } catch (std::out_of_range& e) {
86115       {
86116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86117       };
86118     } catch (std::exception& e) {
86119       {
86120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (...) {
86123       {
86124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86125       };
86126     }
86127   }
86128   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86129
86130   //argout typemap for const std::string&
86131
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86137   void * jresult ;
86138   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86139
86140   {
86141     try {
86142       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
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 = (void *)result;
86158   return jresult;
86159 }
86160
86161
86162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86163   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86164
86165   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86166   {
86167     try {
86168       delete arg1;
86169     } catch (std::out_of_range& e) {
86170       {
86171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86172       };
86173     } catch (std::exception& e) {
86174       {
86175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86176       };
86177     } catch (...) {
86178       {
86179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86180       };
86181     }
86182   }
86183 }
86184
86185
86186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86187   void * jresult ;
86188   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86189   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86190
86191   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86192   if (!arg1) {
86193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86194     return 0;
86195   }
86196   {
86197     try {
86198       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86199     } catch (std::out_of_range& e) {
86200       {
86201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86202       };
86203     } catch (std::exception& e) {
86204       {
86205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (...) {
86208       {
86209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86210       };
86211     }
86212   }
86213   jresult = (void *)result;
86214   return jresult;
86215 }
86216
86217
86218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86219   void * jresult ;
86220   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86221   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86222   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86223
86224   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86225   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86226   if (!arg2) {
86227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86228     return 0;
86229   }
86230   {
86231     try {
86232       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86233     } catch (std::out_of_range& e) {
86234       {
86235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (std::exception& e) {
86238       {
86239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (...) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86244       };
86245     }
86246   }
86247   jresult = (void *)result;
86248   return jresult;
86249 }
86250
86251
86252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86253   void * jresult ;
86254   Dali::Toolkit::AsyncImageLoader result;
86255
86256   {
86257     try {
86258       result = Dali::Toolkit::AsyncImageLoader::New();
86259     } catch (std::out_of_range& e) {
86260       {
86261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86262       };
86263     } catch (std::exception& e) {
86264       {
86265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86266       };
86267     } catch (...) {
86268       {
86269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86270       };
86271     }
86272   }
86273   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86274   return jresult;
86275 }
86276
86277
86278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86279   void * jresult ;
86280   Dali::BaseHandle arg1 ;
86281   Dali::BaseHandle *argp1 ;
86282   Dali::Toolkit::AsyncImageLoader result;
86283
86284   argp1 = (Dali::BaseHandle *)jarg1;
86285   if (!argp1) {
86286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86287     return 0;
86288   }
86289   arg1 = *argp1;
86290   {
86291     try {
86292       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86293     } catch (std::out_of_range& e) {
86294       {
86295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86296       };
86297     } catch (std::exception& e) {
86298       {
86299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86300       };
86301     } catch (...) {
86302       {
86303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86304       };
86305     }
86306   }
86307   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86308   return jresult;
86309 }
86310
86311
86312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86313   unsigned int jresult ;
86314   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86315   std::string *arg2 = 0 ;
86316   uint32_t result;
86317
86318   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86319   if (!jarg2) {
86320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86321     return 0;
86322   }
86323   std::string arg2_str(jarg2);
86324   arg2 = &arg2_str;
86325   {
86326     try {
86327       result = (arg1)->Load((std::string const &)*arg2);
86328     } catch (std::out_of_range& e) {
86329       {
86330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (std::exception& e) {
86333       {
86334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86335       };
86336     } catch (...) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86339       };
86340     }
86341   }
86342   jresult = result;
86343
86344   //argout typemap for const std::string&
86345
86346   return jresult;
86347 }
86348
86349
86350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86351   unsigned int jresult ;
86352   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86353   std::string *arg2 = 0 ;
86354   Dali::ImageDimensions arg3 ;
86355   Dali::ImageDimensions *argp3 ;
86356   uint32_t result;
86357
86358   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86359   if (!jarg2) {
86360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86361     return 0;
86362   }
86363   std::string arg2_str(jarg2);
86364   arg2 = &arg2_str;
86365   argp3 = (Dali::ImageDimensions *)jarg3;
86366   if (!argp3) {
86367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86368     return 0;
86369   }
86370   arg3 = *argp3;
86371   {
86372     try {
86373       result = (arg1)->Load((std::string const &)*arg2,arg3);
86374     } catch (std::out_of_range& e) {
86375       {
86376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86377       };
86378     } catch (std::exception& e) {
86379       {
86380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86381       };
86382     } catch (...) {
86383       {
86384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86385       };
86386     }
86387   }
86388   jresult = result;
86389
86390   //argout typemap for const std::string&
86391
86392   return jresult;
86393 }
86394
86395
86396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86397   unsigned int jresult ;
86398   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86399   std::string *arg2 = 0 ;
86400   Dali::ImageDimensions arg3 ;
86401   Dali::FittingMode::Type arg4 ;
86402   Dali::SamplingMode::Type arg5 ;
86403   bool arg6 ;
86404   Dali::ImageDimensions *argp3 ;
86405   uint32_t result;
86406
86407   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86408   if (!jarg2) {
86409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86410     return 0;
86411   }
86412   std::string arg2_str(jarg2);
86413   arg2 = &arg2_str;
86414   argp3 = (Dali::ImageDimensions *)jarg3;
86415   if (!argp3) {
86416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86417     return 0;
86418   }
86419   arg3 = *argp3;
86420   arg4 = (Dali::FittingMode::Type)jarg4;
86421   arg5 = (Dali::SamplingMode::Type)jarg5;
86422   arg6 = jarg6 ? true : false;
86423   {
86424     try {
86425       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86426     } catch (std::out_of_range& e) {
86427       {
86428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (std::exception& e) {
86431       {
86432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86433       };
86434     } catch (...) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86437       };
86438     }
86439   }
86440   jresult = result;
86441
86442   //argout typemap for const std::string&
86443
86444   return jresult;
86445 }
86446
86447
86448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86449   unsigned int jresult ;
86450   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86451   uint32_t arg2 ;
86452   bool result;
86453
86454   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86455   arg2 = (uint32_t)jarg2;
86456   {
86457     try {
86458       result = (bool)(arg1)->Cancel(arg2);
86459     } catch (std::out_of_range& e) {
86460       {
86461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86462       };
86463     } catch (std::exception& e) {
86464       {
86465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86466       };
86467     } catch (...) {
86468       {
86469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86470       };
86471     }
86472   }
86473   jresult = result;
86474   return jresult;
86475 }
86476
86477
86478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86479   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86480
86481   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86482   {
86483     try {
86484       (arg1)->CancelAll();
86485     } catch (std::out_of_range& e) {
86486       {
86487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86488       };
86489     } catch (std::exception& e) {
86490       {
86491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86492       };
86493     } catch (...) {
86494       {
86495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86496       };
86497     }
86498   }
86499 }
86500
86501
86502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86503   void * jresult ;
86504   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86505   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86506
86507   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86508   {
86509     try {
86510       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86511     } catch (std::out_of_range& e) {
86512       {
86513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86514       };
86515     } catch (std::exception& e) {
86516       {
86517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86518       };
86519     } catch (...) {
86520       {
86521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86522       };
86523     }
86524   }
86525   jresult = (void *)result;
86526   return jresult;
86527 }
86528
86529
86530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86531   void * jresult ;
86532   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86533   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86534
86535   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86536   {
86537     try {
86538       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86539     } catch (std::out_of_range& e) {
86540       {
86541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86542       };
86543     } catch (std::exception& e) {
86544       {
86545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86546       };
86547     } catch (...) {
86548       {
86549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86550       };
86551     }
86552   }
86553   jresult = (void *)result;
86554   return jresult;
86555 }
86556
86557
86558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86559   void * jresult ;
86560   std::string *arg1 = 0 ;
86561   Dali::PixelData result;
86562
86563   if (!jarg1) {
86564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86565     return 0;
86566   }
86567   std::string arg1_str(jarg1);
86568   arg1 = &arg1_str;
86569   {
86570     try {
86571       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86572     } catch (std::out_of_range& e) {
86573       {
86574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86575       };
86576     } catch (std::exception& e) {
86577       {
86578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86579       };
86580     } catch (...) {
86581       {
86582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86583       };
86584     }
86585   }
86586   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86587
86588   //argout typemap for const std::string&
86589
86590   return jresult;
86591 }
86592
86593
86594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86595   void * jresult ;
86596   std::string *arg1 = 0 ;
86597   Dali::ImageDimensions arg2 ;
86598   Dali::ImageDimensions *argp2 ;
86599   Dali::PixelData result;
86600
86601   if (!jarg1) {
86602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86603     return 0;
86604   }
86605   std::string arg1_str(jarg1);
86606   arg1 = &arg1_str;
86607   argp2 = (Dali::ImageDimensions *)jarg2;
86608   if (!argp2) {
86609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86610     return 0;
86611   }
86612   arg2 = *argp2;
86613   {
86614     try {
86615       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86616     } catch (std::out_of_range& e) {
86617       {
86618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86619       };
86620     } catch (std::exception& e) {
86621       {
86622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86623       };
86624     } catch (...) {
86625       {
86626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86627       };
86628     }
86629   }
86630   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86631
86632   //argout typemap for const std::string&
86633
86634   return jresult;
86635 }
86636
86637
86638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86639   void * jresult ;
86640   std::string *arg1 = 0 ;
86641   Dali::ImageDimensions arg2 ;
86642   Dali::FittingMode::Type arg3 ;
86643   Dali::SamplingMode::Type arg4 ;
86644   bool arg5 ;
86645   Dali::ImageDimensions *argp2 ;
86646   Dali::PixelData result;
86647
86648   if (!jarg1) {
86649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86650     return 0;
86651   }
86652   std::string arg1_str(jarg1);
86653   arg1 = &arg1_str;
86654   argp2 = (Dali::ImageDimensions *)jarg2;
86655   if (!argp2) {
86656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86657     return 0;
86658   }
86659   arg2 = *argp2;
86660   arg3 = (Dali::FittingMode::Type)jarg3;
86661   arg4 = (Dali::SamplingMode::Type)jarg4;
86662   arg5 = jarg5 ? true : false;
86663   {
86664     try {
86665       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86677       };
86678     }
86679   }
86680   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86681
86682   //argout typemap for const std::string&
86683
86684   return jresult;
86685 }
86686
86687
86688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86689   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86690
86691   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86692   {
86693     try {
86694       delete arg1;
86695     } catch (std::out_of_range& e) {
86696       {
86697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86698       };
86699     } catch (std::exception& e) {
86700       {
86701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86702       };
86703     } catch (...) {
86704       {
86705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86706       };
86707     }
86708   }
86709 }
86710
86711
86712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86713   void * jresult ;
86714   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86715   Dali::Actor arg2 ;
86716   Dali::Actor arg3 ;
86717   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86718   Dali::Actor *argp2 ;
86719   Dali::Actor *argp3 ;
86720   Dali::Actor result;
86721
86722   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86723   argp2 = (Dali::Actor *)jarg2;
86724   if (!argp2) {
86725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86726     return 0;
86727   }
86728   arg2 = *argp2;
86729   argp3 = (Dali::Actor *)jarg3;
86730   if (!argp3) {
86731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86732     return 0;
86733   }
86734   arg3 = *argp3;
86735   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86736   {
86737     try {
86738       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86739     } catch (std::out_of_range& e) {
86740       {
86741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86742       };
86743     } catch (std::exception& e) {
86744       {
86745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86746       };
86747     } catch (...) {
86748       {
86749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86750       };
86751     }
86752   }
86753   jresult = new Dali::Actor((const Dali::Actor &)result);
86754   return jresult;
86755 }
86756
86757
86758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86759   void * jresult ;
86760   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86761
86762   {
86763     try {
86764       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86765     } catch (std::out_of_range& e) {
86766       {
86767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86768       };
86769     } catch (std::exception& e) {
86770       {
86771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86772       };
86773     } catch (...) {
86774       {
86775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86776       };
86777     }
86778   }
86779   jresult = (void *)result;
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86785   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86786   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86787   if (director) {
86788     director->swig_connect_director(callback0);
86789   }
86790 }
86791
86792
86793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86794   KeyboardFocusManager arg1 ;
86795   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86796   KeyboardFocusManager *argp1 ;
86797
86798   argp1 = (KeyboardFocusManager *)jarg1;
86799   if (!argp1) {
86800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86801     return ;
86802   }
86803   arg1 = *argp1;
86804   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86805   if (!arg2) {
86806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86807     return ;
86808   }
86809   {
86810     try {
86811       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86812     } catch (std::out_of_range& e) {
86813       {
86814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86815       };
86816     } catch (std::exception& e) {
86817       {
86818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86819       };
86820     } catch (...) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86823       };
86824     }
86825   }
86826 }
86827
86828
86829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86830   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86831
86832   arg1 = (std::vector< unsigned int > *)jarg1;
86833   {
86834     try {
86835       (arg1)->clear();
86836     } catch (std::out_of_range& e) {
86837       {
86838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86839       };
86840     } catch (std::exception& e) {
86841       {
86842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86843       };
86844     } catch (...) {
86845       {
86846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86847       };
86848     }
86849   }
86850 }
86851
86852
86853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86854   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86855   unsigned int *arg2 = 0 ;
86856   unsigned int temp2 ;
86857
86858   arg1 = (std::vector< unsigned int > *)jarg1;
86859   temp2 = (unsigned int)jarg2;
86860   arg2 = &temp2;
86861   {
86862     try {
86863       (arg1)->push_back((unsigned int const &)*arg2);
86864     } catch (std::out_of_range& e) {
86865       {
86866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86867       };
86868     } catch (std::exception& e) {
86869       {
86870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86871       };
86872     } catch (...) {
86873       {
86874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86875       };
86876     }
86877   }
86878 }
86879
86880
86881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86882   unsigned long jresult ;
86883   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86884   std::vector< unsigned int >::size_type result;
86885
86886   arg1 = (std::vector< unsigned int > *)jarg1;
86887   {
86888     try {
86889       result = ((std::vector< unsigned int > const *)arg1)->size();
86890     } catch (std::out_of_range& e) {
86891       {
86892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86893       };
86894     } catch (std::exception& e) {
86895       {
86896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86897       };
86898     } catch (...) {
86899       {
86900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86901       };
86902     }
86903   }
86904   jresult = (unsigned long)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86910   unsigned long jresult ;
86911   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86912   std::vector< unsigned int >::size_type result;
86913
86914   arg1 = (std::vector< unsigned int > *)jarg1;
86915   {
86916     try {
86917       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86918     } catch (std::out_of_range& e) {
86919       {
86920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86921       };
86922     } catch (std::exception& e) {
86923       {
86924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86925       };
86926     } catch (...) {
86927       {
86928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86929       };
86930     }
86931   }
86932   jresult = (unsigned long)result;
86933   return jresult;
86934 }
86935
86936
86937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86938   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86939   std::vector< unsigned int >::size_type arg2 ;
86940
86941   arg1 = (std::vector< unsigned int > *)jarg1;
86942   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86943   {
86944     try {
86945       (arg1)->reserve(arg2);
86946     } catch (std::out_of_range& e) {
86947       {
86948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86949       };
86950     } catch (std::exception& e) {
86951       {
86952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86953       };
86954     } catch (...) {
86955       {
86956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86957       };
86958     }
86959   }
86960 }
86961
86962
86963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86964   void * jresult ;
86965   std::vector< unsigned int > *result = 0 ;
86966
86967   {
86968     try {
86969       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86970     } catch (std::out_of_range& e) {
86971       {
86972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86973       };
86974     } catch (std::exception& e) {
86975       {
86976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86977       };
86978     } catch (...) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86981       };
86982     }
86983   }
86984   jresult = (void *)result;
86985   return jresult;
86986 }
86987
86988
86989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86990   void * jresult ;
86991   std::vector< unsigned int > *arg1 = 0 ;
86992   std::vector< unsigned int > *result = 0 ;
86993
86994   arg1 = (std::vector< unsigned int > *)jarg1;
86995   if (!arg1) {
86996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86997     return 0;
86998   }
86999   {
87000     try {
87001       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87009       };
87010     } catch (...) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87013       };
87014     }
87015   }
87016   jresult = (void *)result;
87017   return jresult;
87018 }
87019
87020
87021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87022   void * jresult ;
87023   int arg1 ;
87024   std::vector< unsigned int > *result = 0 ;
87025
87026   arg1 = (int)jarg1;
87027   {
87028     try {
87029       try {
87030         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87031       }
87032       catch(std::out_of_range &_e) {
87033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87034         return 0;
87035       }
87036
87037     } catch (std::out_of_range& e) {
87038       {
87039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87040       };
87041     } catch (std::exception& e) {
87042       {
87043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87048       };
87049     }
87050   }
87051   jresult = (void *)result;
87052   return jresult;
87053 }
87054
87055
87056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87057   unsigned int jresult ;
87058   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87059   int arg2 ;
87060   unsigned int result;
87061
87062   arg1 = (std::vector< unsigned int > *)jarg1;
87063   arg2 = (int)jarg2;
87064   {
87065     try {
87066       try {
87067         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87068       }
87069       catch(std::out_of_range &_e) {
87070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87071         return 0;
87072       }
87073
87074     } catch (std::out_of_range& e) {
87075       {
87076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87077       };
87078     } catch (std::exception& e) {
87079       {
87080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (...) {
87083       {
87084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87085       };
87086     }
87087   }
87088   jresult = result;
87089   return jresult;
87090 }
87091
87092
87093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87094   unsigned int jresult ;
87095   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87096   int arg2 ;
87097   unsigned int *result = 0 ;
87098
87099   arg1 = (std::vector< unsigned int > *)jarg1;
87100   arg2 = (int)jarg2;
87101   {
87102     try {
87103       try {
87104         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87105       }
87106       catch(std::out_of_range &_e) {
87107         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87108         return 0;
87109       }
87110
87111     } catch (std::out_of_range& e) {
87112       {
87113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87114       };
87115     } catch (std::exception& e) {
87116       {
87117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87118       };
87119     } catch (...) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87122       };
87123     }
87124   }
87125   jresult = *result;
87126   return jresult;
87127 }
87128
87129
87130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87131   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87132   int arg2 ;
87133   unsigned int *arg3 = 0 ;
87134   unsigned int temp3 ;
87135
87136   arg1 = (std::vector< unsigned int > *)jarg1;
87137   arg2 = (int)jarg2;
87138   temp3 = (unsigned int)jarg3;
87139   arg3 = &temp3;
87140   {
87141     try {
87142       try {
87143         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87144       }
87145       catch(std::out_of_range &_e) {
87146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87147         return ;
87148       }
87149
87150     } catch (std::out_of_range& e) {
87151       {
87152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87153       };
87154     } catch (std::exception& e) {
87155       {
87156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87157       };
87158     } catch (...) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87161       };
87162     }
87163   }
87164 }
87165
87166
87167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87168   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87169   std::vector< unsigned int > *arg2 = 0 ;
87170
87171   arg1 = (std::vector< unsigned int > *)jarg1;
87172   arg2 = (std::vector< unsigned int > *)jarg2;
87173   if (!arg2) {
87174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87175     return ;
87176   }
87177   {
87178     try {
87179       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87180     } catch (std::out_of_range& e) {
87181       {
87182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87183       };
87184     } catch (std::exception& e) {
87185       {
87186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87187       };
87188     } catch (...) {
87189       {
87190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87191       };
87192     }
87193   }
87194 }
87195
87196
87197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87198   void * jresult ;
87199   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87200   int arg2 ;
87201   int arg3 ;
87202   std::vector< unsigned int > *result = 0 ;
87203
87204   arg1 = (std::vector< unsigned int > *)jarg1;
87205   arg2 = (int)jarg2;
87206   arg3 = (int)jarg3;
87207   {
87208     try {
87209       try {
87210         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87211       }
87212       catch(std::out_of_range &_e) {
87213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87214         return 0;
87215       }
87216       catch(std::invalid_argument &_e) {
87217         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87218         return 0;
87219       }
87220
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87228       };
87229     } catch (...) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87232       };
87233     }
87234   }
87235   jresult = (void *)result;
87236   return jresult;
87237 }
87238
87239
87240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87241   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87242   int arg2 ;
87243   unsigned int *arg3 = 0 ;
87244   unsigned int temp3 ;
87245
87246   arg1 = (std::vector< unsigned int > *)jarg1;
87247   arg2 = (int)jarg2;
87248   temp3 = (unsigned int)jarg3;
87249   arg3 = &temp3;
87250   {
87251     try {
87252       try {
87253         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87254       }
87255       catch(std::out_of_range &_e) {
87256         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87257         return ;
87258       }
87259
87260     } catch (std::out_of_range& e) {
87261       {
87262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87263       };
87264     } catch (std::exception& e) {
87265       {
87266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87267       };
87268     } catch (...) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87271       };
87272     }
87273   }
87274 }
87275
87276
87277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87278   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87279   int arg2 ;
87280   std::vector< unsigned int > *arg3 = 0 ;
87281
87282   arg1 = (std::vector< unsigned int > *)jarg1;
87283   arg2 = (int)jarg2;
87284   arg3 = (std::vector< unsigned int > *)jarg3;
87285   if (!arg3) {
87286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87287     return ;
87288   }
87289   {
87290     try {
87291       try {
87292         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87293       }
87294       catch(std::out_of_range &_e) {
87295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87296         return ;
87297       }
87298
87299     } catch (std::out_of_range& e) {
87300       {
87301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87302       };
87303     } catch (std::exception& e) {
87304       {
87305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87306       };
87307     } catch (...) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87310       };
87311     }
87312   }
87313 }
87314
87315
87316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87317   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87318   int arg2 ;
87319
87320   arg1 = (std::vector< unsigned int > *)jarg1;
87321   arg2 = (int)jarg2;
87322   {
87323     try {
87324       try {
87325         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87326       }
87327       catch(std::out_of_range &_e) {
87328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87329         return ;
87330       }
87331
87332     } catch (std::out_of_range& e) {
87333       {
87334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87335       };
87336     } catch (std::exception& e) {
87337       {
87338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87339       };
87340     } catch (...) {
87341       {
87342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87343       };
87344     }
87345   }
87346 }
87347
87348
87349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87350   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87351   int arg2 ;
87352   int arg3 ;
87353
87354   arg1 = (std::vector< unsigned int > *)jarg1;
87355   arg2 = (int)jarg2;
87356   arg3 = (int)jarg3;
87357   {
87358     try {
87359       try {
87360         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87361       }
87362       catch(std::out_of_range &_e) {
87363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87364         return ;
87365       }
87366       catch(std::invalid_argument &_e) {
87367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87368         return ;
87369       }
87370
87371     } catch (std::out_of_range& e) {
87372       {
87373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87374       };
87375     } catch (std::exception& e) {
87376       {
87377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87378       };
87379     } catch (...) {
87380       {
87381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87382       };
87383     }
87384   }
87385 }
87386
87387
87388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87389   void * jresult ;
87390   unsigned int *arg1 = 0 ;
87391   int arg2 ;
87392   unsigned int temp1 ;
87393   std::vector< unsigned int > *result = 0 ;
87394
87395   temp1 = (unsigned int)jarg1;
87396   arg1 = &temp1;
87397   arg2 = (int)jarg2;
87398   {
87399     try {
87400       try {
87401         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87402       }
87403       catch(std::out_of_range &_e) {
87404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87405         return 0;
87406       }
87407
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87415       };
87416     } catch (...) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87419       };
87420     }
87421   }
87422   jresult = (void *)result;
87423   return jresult;
87424 }
87425
87426
87427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87428   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87429
87430   arg1 = (std::vector< unsigned int > *)jarg1;
87431   {
87432     try {
87433       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87434     } catch (std::out_of_range& e) {
87435       {
87436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87437       };
87438     } catch (std::exception& e) {
87439       {
87440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87441       };
87442     } catch (...) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87445       };
87446     }
87447   }
87448 }
87449
87450
87451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87452   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87453   int arg2 ;
87454   int arg3 ;
87455
87456   arg1 = (std::vector< unsigned int > *)jarg1;
87457   arg2 = (int)jarg2;
87458   arg3 = (int)jarg3;
87459   {
87460     try {
87461       try {
87462         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87463       }
87464       catch(std::out_of_range &_e) {
87465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87466         return ;
87467       }
87468       catch(std::invalid_argument &_e) {
87469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87470         return ;
87471       }
87472
87473     } catch (std::out_of_range& e) {
87474       {
87475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87476       };
87477     } catch (std::exception& e) {
87478       {
87479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87480       };
87481     } catch (...) {
87482       {
87483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87484       };
87485     }
87486   }
87487 }
87488
87489
87490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87491   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87492   int arg2 ;
87493   std::vector< unsigned int > *arg3 = 0 ;
87494
87495   arg1 = (std::vector< unsigned int > *)jarg1;
87496   arg2 = (int)jarg2;
87497   arg3 = (std::vector< unsigned int > *)jarg3;
87498   if (!arg3) {
87499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87500     return ;
87501   }
87502   {
87503     try {
87504       try {
87505         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87506       }
87507       catch(std::out_of_range &_e) {
87508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87509         return ;
87510       }
87511
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87519       };
87520     } catch (...) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87523       };
87524     }
87525   }
87526 }
87527
87528
87529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87530   unsigned int jresult ;
87531   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87532   unsigned int *arg2 = 0 ;
87533   unsigned int temp2 ;
87534   bool result;
87535
87536   arg1 = (std::vector< unsigned int > *)jarg1;
87537   temp2 = (unsigned int)jarg2;
87538   arg2 = &temp2;
87539   {
87540     try {
87541       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87542     } catch (std::out_of_range& e) {
87543       {
87544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87545       };
87546     } catch (std::exception& e) {
87547       {
87548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87549       };
87550     } catch (...) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87553       };
87554     }
87555   }
87556   jresult = result;
87557   return jresult;
87558 }
87559
87560
87561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87562   int jresult ;
87563   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87564   unsigned int *arg2 = 0 ;
87565   unsigned int temp2 ;
87566   int result;
87567
87568   arg1 = (std::vector< unsigned int > *)jarg1;
87569   temp2 = (unsigned int)jarg2;
87570   arg2 = &temp2;
87571   {
87572     try {
87573       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87574     } catch (std::out_of_range& e) {
87575       {
87576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87577       };
87578     } catch (std::exception& e) {
87579       {
87580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87581       };
87582     } catch (...) {
87583       {
87584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87585       };
87586     }
87587   }
87588   jresult = result;
87589   return jresult;
87590 }
87591
87592
87593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87594   int jresult ;
87595   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87596   unsigned int *arg2 = 0 ;
87597   unsigned int temp2 ;
87598   int result;
87599
87600   arg1 = (std::vector< unsigned int > *)jarg1;
87601   temp2 = (unsigned int)jarg2;
87602   arg2 = &temp2;
87603   {
87604     try {
87605       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87606     } catch (std::out_of_range& e) {
87607       {
87608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87609       };
87610     } catch (std::exception& e) {
87611       {
87612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87613       };
87614     } catch (...) {
87615       {
87616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87617       };
87618     }
87619   }
87620   jresult = result;
87621   return jresult;
87622 }
87623
87624
87625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87626   unsigned int jresult ;
87627   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87628   unsigned int *arg2 = 0 ;
87629   unsigned int temp2 ;
87630   bool result;
87631
87632   arg1 = (std::vector< unsigned int > *)jarg1;
87633   temp2 = (unsigned int)jarg2;
87634   arg2 = &temp2;
87635   {
87636     try {
87637       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87638     } catch (std::out_of_range& e) {
87639       {
87640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87641       };
87642     } catch (std::exception& e) {
87643       {
87644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87645       };
87646     } catch (...) {
87647       {
87648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87649       };
87650     }
87651   }
87652   jresult = result;
87653   return jresult;
87654 }
87655
87656
87657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87658   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87659
87660   arg1 = (std::vector< unsigned int > *)jarg1;
87661   {
87662     try {
87663       delete arg1;
87664     } catch (std::out_of_range& e) {
87665       {
87666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87667       };
87668     } catch (std::exception& e) {
87669       {
87670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87671       };
87672     } catch (...) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87675       };
87676     }
87677   }
87678 }
87679
87680
87681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87682   void * jresult ;
87683   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87684
87685   {
87686     try {
87687       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87688     } catch (std::out_of_range& e) {
87689       {
87690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87691       };
87692     } catch (std::exception& e) {
87693       {
87694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87695       };
87696     } catch (...) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87699       };
87700     }
87701   }
87702   jresult = (void *)result;
87703   return jresult;
87704 }
87705
87706
87707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87708   void * jresult ;
87709   unsigned int arg1 ;
87710   Dali::Actor arg2 ;
87711   Dali::Actor *argp2 ;
87712   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87713
87714   arg1 = (unsigned int)jarg1;
87715   argp2 = (Dali::Actor *)jarg2;
87716   if (!argp2) {
87717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87718     return 0;
87719   }
87720   arg2 = *argp2;
87721   {
87722     try {
87723       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87724     } catch (std::out_of_range& e) {
87725       {
87726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87727       };
87728     } catch (std::exception& e) {
87729       {
87730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87731       };
87732     } catch (...) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87735       };
87736     }
87737   }
87738   jresult = (void *)result;
87739   return jresult;
87740 }
87741
87742
87743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87744   void * jresult ;
87745   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87746   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87747
87748   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87749   if (!arg1) {
87750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87751     return 0;
87752   }
87753   {
87754     try {
87755       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87756     } catch (std::out_of_range& e) {
87757       {
87758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87759       };
87760     } catch (std::exception& e) {
87761       {
87762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87763       };
87764     } catch (...) {
87765       {
87766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87767       };
87768     }
87769   }
87770   jresult = (void *)result;
87771   return jresult;
87772 }
87773
87774
87775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87776   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87777   unsigned int arg2 ;
87778
87779   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87780   arg2 = (unsigned int)jarg2;
87781   if (arg1) (arg1)->first = arg2;
87782 }
87783
87784
87785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87786   unsigned int jresult ;
87787   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87788   unsigned int result;
87789
87790   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87791   result = (unsigned int) ((arg1)->first);
87792   jresult = result;
87793   return jresult;
87794 }
87795
87796
87797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87798   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87799   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87800
87801   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87802   arg2 = (Dali::Actor *)jarg2;
87803   if (arg1) (arg1)->second = *arg2;
87804 }
87805
87806
87807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87808   void * jresult ;
87809   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87810   Dali::Actor *result = 0 ;
87811
87812   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87813   result = (Dali::Actor *)& ((arg1)->second);
87814   jresult = (void *)result;
87815   return jresult;
87816 }
87817
87818
87819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87820   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87821
87822   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87823   {
87824     try {
87825       delete arg1;
87826     } catch (std::out_of_range& e) {
87827       {
87828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87829       };
87830     } catch (std::exception& e) {
87831       {
87832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87833       };
87834     } catch (...) {
87835       {
87836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87837       };
87838     }
87839   }
87840 }
87841
87842
87843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87844   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87845
87846   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87847   {
87848     try {
87849       (arg1)->clear();
87850     } catch (std::out_of_range& e) {
87851       {
87852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87853       };
87854     } catch (std::exception& e) {
87855       {
87856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87857       };
87858     } catch (...) {
87859       {
87860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87861       };
87862     }
87863   }
87864 }
87865
87866
87867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87868   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87869   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87870
87871   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87872   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87873   if (!arg2) {
87874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87875     return ;
87876   }
87877   {
87878     try {
87879       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87880     } catch (std::out_of_range& e) {
87881       {
87882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87883       };
87884     } catch (std::exception& e) {
87885       {
87886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87887       };
87888     } catch (...) {
87889       {
87890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87891       };
87892     }
87893   }
87894 }
87895
87896
87897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87898   unsigned long jresult ;
87899   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87900   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87901
87902   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87903   {
87904     try {
87905       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87906     } catch (std::out_of_range& e) {
87907       {
87908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87909       };
87910     } catch (std::exception& e) {
87911       {
87912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87913       };
87914     } catch (...) {
87915       {
87916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87917       };
87918     }
87919   }
87920   jresult = (unsigned long)result;
87921   return jresult;
87922 }
87923
87924
87925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87926   unsigned long jresult ;
87927   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87928   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87929
87930   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87931   {
87932     try {
87933       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87934     } catch (std::out_of_range& e) {
87935       {
87936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87937       };
87938     } catch (std::exception& e) {
87939       {
87940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87941       };
87942     } catch (...) {
87943       {
87944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87945       };
87946     }
87947   }
87948   jresult = (unsigned long)result;
87949   return jresult;
87950 }
87951
87952
87953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87954   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87955   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87956
87957   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87958   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87959   {
87960     try {
87961       (arg1)->reserve(arg2);
87962     } catch (std::out_of_range& e) {
87963       {
87964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87965       };
87966     } catch (std::exception& e) {
87967       {
87968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87969       };
87970     } catch (...) {
87971       {
87972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87973       };
87974     }
87975   }
87976 }
87977
87978
87979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87980   void * jresult ;
87981   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87982
87983   {
87984     try {
87985       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87993       };
87994     } catch (...) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87997       };
87998     }
87999   }
88000   jresult = (void *)result;
88001   return jresult;
88002 }
88003
88004
88005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88006   void * jresult ;
88007   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88008   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88009
88010   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88011   if (!arg1) {
88012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88013     return 0;
88014   }
88015   {
88016     try {
88017       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);
88018     } catch (std::out_of_range& e) {
88019       {
88020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88021       };
88022     } catch (std::exception& e) {
88023       {
88024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88025       };
88026     } catch (...) {
88027       {
88028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88029       };
88030     }
88031   }
88032   jresult = (void *)result;
88033   return jresult;
88034 }
88035
88036
88037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88038   void * jresult ;
88039   int arg1 ;
88040   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88041
88042   arg1 = (int)jarg1;
88043   {
88044     try {
88045       try {
88046         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);
88047       }
88048       catch(std::out_of_range &_e) {
88049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88050         return 0;
88051       }
88052
88053     } catch (std::out_of_range& e) {
88054       {
88055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (std::exception& e) {
88058       {
88059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88060       };
88061     } catch (...) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88064       };
88065     }
88066   }
88067   jresult = (void *)result;
88068   return jresult;
88069 }
88070
88071
88072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88073   void * jresult ;
88074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88075   int arg2 ;
88076   std::pair< unsigned int,Dali::Actor > result;
88077
88078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88079   arg2 = (int)jarg2;
88080   {
88081     try {
88082       try {
88083         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88084       }
88085       catch(std::out_of_range &_e) {
88086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88087         return 0;
88088       }
88089
88090     } catch (std::out_of_range& e) {
88091       {
88092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88093       };
88094     } catch (std::exception& e) {
88095       {
88096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (...) {
88099       {
88100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88101       };
88102     }
88103   }
88104   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88105   return jresult;
88106 }
88107
88108
88109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88110   void * jresult ;
88111   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88112   int arg2 ;
88113   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88114
88115   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88116   arg2 = (int)jarg2;
88117   {
88118     try {
88119       try {
88120         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88121       }
88122       catch(std::out_of_range &_e) {
88123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88124         return 0;
88125       }
88126
88127     } catch (std::out_of_range& e) {
88128       {
88129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88130       };
88131     } catch (std::exception& e) {
88132       {
88133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88134       };
88135     } catch (...) {
88136       {
88137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88138       };
88139     }
88140   }
88141   jresult = (void *)result;
88142   return jresult;
88143 }
88144
88145
88146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88147   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88148   int arg2 ;
88149   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88150
88151   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88152   arg2 = (int)jarg2;
88153   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88154   if (!arg3) {
88155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88156     return ;
88157   }
88158   {
88159     try {
88160       try {
88161         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);
88162       }
88163       catch(std::out_of_range &_e) {
88164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88165         return ;
88166       }
88167
88168     } catch (std::out_of_range& e) {
88169       {
88170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88171       };
88172     } catch (std::exception& e) {
88173       {
88174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88175       };
88176     } catch (...) {
88177       {
88178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88179       };
88180     }
88181   }
88182 }
88183
88184
88185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88186   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88187   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88188
88189   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88190   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88191   if (!arg2) {
88192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88193     return ;
88194   }
88195   {
88196     try {
88197       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);
88198     } catch (std::out_of_range& e) {
88199       {
88200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88201       };
88202     } catch (std::exception& e) {
88203       {
88204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88205       };
88206     } catch (...) {
88207       {
88208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88209       };
88210     }
88211   }
88212 }
88213
88214
88215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88216   void * jresult ;
88217   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88218   int arg2 ;
88219   int arg3 ;
88220   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88221
88222   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88223   arg2 = (int)jarg2;
88224   arg3 = (int)jarg3;
88225   {
88226     try {
88227       try {
88228         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);
88229       }
88230       catch(std::out_of_range &_e) {
88231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88232         return 0;
88233       }
88234       catch(std::invalid_argument &_e) {
88235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88236         return 0;
88237       }
88238
88239     } catch (std::out_of_range& e) {
88240       {
88241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88242       };
88243     } catch (std::exception& e) {
88244       {
88245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88246       };
88247     } catch (...) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88250       };
88251     }
88252   }
88253   jresult = (void *)result;
88254   return jresult;
88255 }
88256
88257
88258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88259   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88260   int arg2 ;
88261   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88262
88263   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88264   arg2 = (int)jarg2;
88265   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88266   if (!arg3) {
88267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88268     return ;
88269   }
88270   {
88271     try {
88272       try {
88273         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);
88274       }
88275       catch(std::out_of_range &_e) {
88276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88277         return ;
88278       }
88279
88280     } catch (std::out_of_range& e) {
88281       {
88282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88283       };
88284     } catch (std::exception& e) {
88285       {
88286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88287       };
88288     } catch (...) {
88289       {
88290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88291       };
88292     }
88293   }
88294 }
88295
88296
88297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88298   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88299   int arg2 ;
88300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88301
88302   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88303   arg2 = (int)jarg2;
88304   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88305   if (!arg3) {
88306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88307     return ;
88308   }
88309   {
88310     try {
88311       try {
88312         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);
88313       }
88314       catch(std::out_of_range &_e) {
88315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88316         return ;
88317       }
88318
88319     } catch (std::out_of_range& e) {
88320       {
88321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88322       };
88323     } catch (std::exception& e) {
88324       {
88325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88326       };
88327     } catch (...) {
88328       {
88329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88330       };
88331     }
88332   }
88333 }
88334
88335
88336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88337   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88338   int arg2 ;
88339
88340   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88341   arg2 = (int)jarg2;
88342   {
88343     try {
88344       try {
88345         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88346       }
88347       catch(std::out_of_range &_e) {
88348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88349         return ;
88350       }
88351
88352     } catch (std::out_of_range& e) {
88353       {
88354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88355       };
88356     } catch (std::exception& e) {
88357       {
88358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88359       };
88360     } catch (...) {
88361       {
88362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88363       };
88364     }
88365   }
88366 }
88367
88368
88369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88370   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88371   int arg2 ;
88372   int arg3 ;
88373
88374   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88375   arg2 = (int)jarg2;
88376   arg3 = (int)jarg3;
88377   {
88378     try {
88379       try {
88380         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88381       }
88382       catch(std::out_of_range &_e) {
88383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88384         return ;
88385       }
88386       catch(std::invalid_argument &_e) {
88387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88388         return ;
88389       }
88390
88391     } catch (std::out_of_range& e) {
88392       {
88393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88394       };
88395     } catch (std::exception& e) {
88396       {
88397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88398       };
88399     } catch (...) {
88400       {
88401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88402       };
88403     }
88404   }
88405 }
88406
88407
88408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88409   void * jresult ;
88410   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88411   int arg2 ;
88412   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88413
88414   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88415   if (!arg1) {
88416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88417     return 0;
88418   }
88419   arg2 = (int)jarg2;
88420   {
88421     try {
88422       try {
88423         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);
88424       }
88425       catch(std::out_of_range &_e) {
88426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88427         return 0;
88428       }
88429
88430     } catch (std::out_of_range& e) {
88431       {
88432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88433       };
88434     } catch (std::exception& e) {
88435       {
88436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88437       };
88438     } catch (...) {
88439       {
88440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88441       };
88442     }
88443   }
88444   jresult = (void *)result;
88445   return jresult;
88446 }
88447
88448
88449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88450   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88451
88452   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88453   {
88454     try {
88455       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88456     } catch (std::out_of_range& e) {
88457       {
88458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88459       };
88460     } catch (std::exception& e) {
88461       {
88462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (...) {
88465       {
88466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88467       };
88468     }
88469   }
88470 }
88471
88472
88473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88474   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88475   int arg2 ;
88476   int arg3 ;
88477
88478   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88479   arg2 = (int)jarg2;
88480   arg3 = (int)jarg3;
88481   {
88482     try {
88483       try {
88484         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88485       }
88486       catch(std::out_of_range &_e) {
88487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88488         return ;
88489       }
88490       catch(std::invalid_argument &_e) {
88491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88492         return ;
88493       }
88494
88495     } catch (std::out_of_range& e) {
88496       {
88497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88498       };
88499     } catch (std::exception& e) {
88500       {
88501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88502       };
88503     } catch (...) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88506       };
88507     }
88508   }
88509 }
88510
88511
88512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88513   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88514   int arg2 ;
88515   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88516
88517   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88518   arg2 = (int)jarg2;
88519   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88520   if (!arg3) {
88521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88522     return ;
88523   }
88524   {
88525     try {
88526       try {
88527         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);
88528       }
88529       catch(std::out_of_range &_e) {
88530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88531         return ;
88532       }
88533
88534     } catch (std::out_of_range& e) {
88535       {
88536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88537       };
88538     } catch (std::exception& e) {
88539       {
88540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88541       };
88542     } catch (...) {
88543       {
88544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88545       };
88546     }
88547   }
88548 }
88549
88550
88551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88552   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88553
88554   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88555   {
88556     try {
88557       delete arg1;
88558     } catch (std::out_of_range& e) {
88559       {
88560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88561       };
88562     } catch (std::exception& e) {
88563       {
88564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88565       };
88566     } catch (...) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88569       };
88570     }
88571   }
88572 }
88573
88574
88575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88576   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88577
88578   arg1 = (std::vector< Dali::Actor > *)jarg1;
88579   {
88580     try {
88581       (arg1)->clear();
88582     } catch (std::out_of_range& e) {
88583       {
88584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88585       };
88586     } catch (std::exception& e) {
88587       {
88588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88589       };
88590     } catch (...) {
88591       {
88592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88593       };
88594     }
88595   }
88596 }
88597
88598
88599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88600   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88601   Dali::Actor *arg2 = 0 ;
88602
88603   arg1 = (std::vector< Dali::Actor > *)jarg1;
88604   arg2 = (Dali::Actor *)jarg2;
88605   if (!arg2) {
88606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88607     return ;
88608   }
88609   {
88610     try {
88611       (arg1)->push_back((Dali::Actor const &)*arg2);
88612     } catch (std::out_of_range& e) {
88613       {
88614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88615       };
88616     } catch (std::exception& e) {
88617       {
88618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88619       };
88620     } catch (...) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88623       };
88624     }
88625   }
88626 }
88627
88628
88629 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88630   unsigned long jresult ;
88631   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88632   std::vector< Dali::Actor >::size_type result;
88633
88634   arg1 = (std::vector< Dali::Actor > *)jarg1;
88635   {
88636     try {
88637       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88638     } catch (std::out_of_range& e) {
88639       {
88640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88641       };
88642     } catch (std::exception& e) {
88643       {
88644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88645       };
88646     } catch (...) {
88647       {
88648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88649       };
88650     }
88651   }
88652   jresult = (unsigned long)result;
88653   return jresult;
88654 }
88655
88656
88657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88658   unsigned long jresult ;
88659   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88660   std::vector< Dali::Actor >::size_type result;
88661
88662   arg1 = (std::vector< Dali::Actor > *)jarg1;
88663   {
88664     try {
88665       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88666     } catch (std::out_of_range& e) {
88667       {
88668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88669       };
88670     } catch (std::exception& e) {
88671       {
88672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88677       };
88678     }
88679   }
88680   jresult = (unsigned long)result;
88681   return jresult;
88682 }
88683
88684
88685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88686   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88687   std::vector< Dali::Actor >::size_type arg2 ;
88688
88689   arg1 = (std::vector< Dali::Actor > *)jarg1;
88690   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88691   {
88692     try {
88693       (arg1)->reserve(arg2);
88694     } catch (std::out_of_range& e) {
88695       {
88696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88697       };
88698     } catch (std::exception& e) {
88699       {
88700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88701       };
88702     } catch (...) {
88703       {
88704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88705       };
88706     }
88707   }
88708 }
88709
88710
88711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88712   void * jresult ;
88713   std::vector< Dali::Actor > *result = 0 ;
88714
88715   {
88716     try {
88717       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88718     } catch (std::out_of_range& e) {
88719       {
88720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88721       };
88722     } catch (std::exception& e) {
88723       {
88724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88725       };
88726     } catch (...) {
88727       {
88728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88729       };
88730     }
88731   }
88732   jresult = (void *)result;
88733   return jresult;
88734 }
88735
88736
88737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88738   void * jresult ;
88739   std::vector< Dali::Actor > *arg1 = 0 ;
88740   std::vector< Dali::Actor > *result = 0 ;
88741
88742   arg1 = (std::vector< Dali::Actor > *)jarg1;
88743   if (!arg1) {
88744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88745     return 0;
88746   }
88747   {
88748     try {
88749       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88750     } catch (std::out_of_range& e) {
88751       {
88752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88753       };
88754     } catch (std::exception& e) {
88755       {
88756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88757       };
88758     } catch (...) {
88759       {
88760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88761       };
88762     }
88763   }
88764   jresult = (void *)result;
88765   return jresult;
88766 }
88767
88768
88769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88770   void * jresult ;
88771   int arg1 ;
88772   std::vector< Dali::Actor > *result = 0 ;
88773
88774   arg1 = (int)jarg1;
88775   {
88776     try {
88777       try {
88778         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88779       }
88780       catch(std::out_of_range &_e) {
88781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88782         return 0;
88783       }
88784
88785     } catch (std::out_of_range& e) {
88786       {
88787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88788       };
88789     } catch (std::exception& e) {
88790       {
88791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88792       };
88793     } catch (...) {
88794       {
88795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88796       };
88797     }
88798   }
88799   jresult = (void *)result;
88800   return jresult;
88801 }
88802
88803
88804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88805   void * jresult ;
88806   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88807   int arg2 ;
88808   Dali::Actor result;
88809
88810   arg1 = (std::vector< Dali::Actor > *)jarg1;
88811   arg2 = (int)jarg2;
88812   {
88813     try {
88814       try {
88815         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88816       }
88817       catch(std::out_of_range &_e) {
88818         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88819         return 0;
88820       }
88821
88822     } catch (std::out_of_range& e) {
88823       {
88824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88825       };
88826     } catch (std::exception& e) {
88827       {
88828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88829       };
88830     } catch (...) {
88831       {
88832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88833       };
88834     }
88835   }
88836   jresult = new Dali::Actor((const Dali::Actor &)result);
88837   return jresult;
88838 }
88839
88840
88841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88842   void * jresult ;
88843   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88844   int arg2 ;
88845   Dali::Actor *result = 0 ;
88846
88847   arg1 = (std::vector< Dali::Actor > *)jarg1;
88848   arg2 = (int)jarg2;
88849   {
88850     try {
88851       try {
88852         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88853       }
88854       catch(std::out_of_range &_e) {
88855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88856         return 0;
88857       }
88858
88859     } catch (std::out_of_range& e) {
88860       {
88861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88862       };
88863     } catch (std::exception& e) {
88864       {
88865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (...) {
88868       {
88869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88870       };
88871     }
88872   }
88873   jresult = (void *)result;
88874   return jresult;
88875 }
88876
88877
88878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88879   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88880   int arg2 ;
88881   Dali::Actor *arg3 = 0 ;
88882
88883   arg1 = (std::vector< Dali::Actor > *)jarg1;
88884   arg2 = (int)jarg2;
88885   arg3 = (Dali::Actor *)jarg3;
88886   if (!arg3) {
88887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88888     return ;
88889   }
88890   {
88891     try {
88892       try {
88893         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88894       }
88895       catch(std::out_of_range &_e) {
88896         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88897         return ;
88898       }
88899
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88907       };
88908     } catch (...) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88911       };
88912     }
88913   }
88914 }
88915
88916
88917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88918   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88919   std::vector< Dali::Actor > *arg2 = 0 ;
88920
88921   arg1 = (std::vector< Dali::Actor > *)jarg1;
88922   arg2 = (std::vector< Dali::Actor > *)jarg2;
88923   if (!arg2) {
88924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88925     return ;
88926   }
88927   {
88928     try {
88929       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88930     } catch (std::out_of_range& e) {
88931       {
88932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88933       };
88934     } catch (std::exception& e) {
88935       {
88936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88937       };
88938     } catch (...) {
88939       {
88940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88941       };
88942     }
88943   }
88944 }
88945
88946
88947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88948   void * jresult ;
88949   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88950   int arg2 ;
88951   int arg3 ;
88952   std::vector< Dali::Actor > *result = 0 ;
88953
88954   arg1 = (std::vector< Dali::Actor > *)jarg1;
88955   arg2 = (int)jarg2;
88956   arg3 = (int)jarg3;
88957   {
88958     try {
88959       try {
88960         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88961       }
88962       catch(std::out_of_range &_e) {
88963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88964         return 0;
88965       }
88966       catch(std::invalid_argument &_e) {
88967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88968         return 0;
88969       }
88970
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (...) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88982       };
88983     }
88984   }
88985   jresult = (void *)result;
88986   return jresult;
88987 }
88988
88989
88990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88991   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88992   int arg2 ;
88993   Dali::Actor *arg3 = 0 ;
88994
88995   arg1 = (std::vector< Dali::Actor > *)jarg1;
88996   arg2 = (int)jarg2;
88997   arg3 = (Dali::Actor *)jarg3;
88998   if (!arg3) {
88999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89000     return ;
89001   }
89002   {
89003     try {
89004       try {
89005         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89006       }
89007       catch(std::out_of_range &_e) {
89008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89009         return ;
89010       }
89011
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89019       };
89020     } catch (...) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89023       };
89024     }
89025   }
89026 }
89027
89028
89029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89030   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89031   int arg2 ;
89032   std::vector< Dali::Actor > *arg3 = 0 ;
89033
89034   arg1 = (std::vector< Dali::Actor > *)jarg1;
89035   arg2 = (int)jarg2;
89036   arg3 = (std::vector< Dali::Actor > *)jarg3;
89037   if (!arg3) {
89038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89039     return ;
89040   }
89041   {
89042     try {
89043       try {
89044         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89045       }
89046       catch(std::out_of_range &_e) {
89047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89048         return ;
89049       }
89050
89051     } catch (std::out_of_range& e) {
89052       {
89053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89054       };
89055     } catch (std::exception& e) {
89056       {
89057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89058       };
89059     } catch (...) {
89060       {
89061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89062       };
89063     }
89064   }
89065 }
89066
89067
89068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89069   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89070   int arg2 ;
89071
89072   arg1 = (std::vector< Dali::Actor > *)jarg1;
89073   arg2 = (int)jarg2;
89074   {
89075     try {
89076       try {
89077         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89078       }
89079       catch(std::out_of_range &_e) {
89080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89081         return ;
89082       }
89083
89084     } catch (std::out_of_range& e) {
89085       {
89086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89087       };
89088     } catch (std::exception& e) {
89089       {
89090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89091       };
89092     } catch (...) {
89093       {
89094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89095       };
89096     }
89097   }
89098 }
89099
89100
89101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89102   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89103   int arg2 ;
89104   int arg3 ;
89105
89106   arg1 = (std::vector< Dali::Actor > *)jarg1;
89107   arg2 = (int)jarg2;
89108   arg3 = (int)jarg3;
89109   {
89110     try {
89111       try {
89112         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89113       }
89114       catch(std::out_of_range &_e) {
89115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89116         return ;
89117       }
89118       catch(std::invalid_argument &_e) {
89119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89120         return ;
89121       }
89122
89123     } catch (std::out_of_range& e) {
89124       {
89125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89126       };
89127     } catch (std::exception& e) {
89128       {
89129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89130       };
89131     } catch (...) {
89132       {
89133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89134       };
89135     }
89136   }
89137 }
89138
89139
89140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89141   void * jresult ;
89142   Dali::Actor *arg1 = 0 ;
89143   int arg2 ;
89144   std::vector< Dali::Actor > *result = 0 ;
89145
89146   arg1 = (Dali::Actor *)jarg1;
89147   if (!arg1) {
89148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89149     return 0;
89150   }
89151   arg2 = (int)jarg2;
89152   {
89153     try {
89154       try {
89155         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89156       }
89157       catch(std::out_of_range &_e) {
89158         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89159         return 0;
89160       }
89161
89162     } catch (std::out_of_range& e) {
89163       {
89164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89165       };
89166     } catch (std::exception& e) {
89167       {
89168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89169       };
89170     } catch (...) {
89171       {
89172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89173       };
89174     }
89175   }
89176   jresult = (void *)result;
89177   return jresult;
89178 }
89179
89180
89181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89182   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89183
89184   arg1 = (std::vector< Dali::Actor > *)jarg1;
89185   {
89186     try {
89187       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89188     } catch (std::out_of_range& e) {
89189       {
89190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89191       };
89192     } catch (std::exception& e) {
89193       {
89194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89195       };
89196     } catch (...) {
89197       {
89198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89199       };
89200     }
89201   }
89202 }
89203
89204
89205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89206   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89207   int arg2 ;
89208   int arg3 ;
89209
89210   arg1 = (std::vector< Dali::Actor > *)jarg1;
89211   arg2 = (int)jarg2;
89212   arg3 = (int)jarg3;
89213   {
89214     try {
89215       try {
89216         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89217       }
89218       catch(std::out_of_range &_e) {
89219         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89220         return ;
89221       }
89222       catch(std::invalid_argument &_e) {
89223         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89224         return ;
89225       }
89226
89227     } catch (std::out_of_range& e) {
89228       {
89229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89230       };
89231     } catch (std::exception& e) {
89232       {
89233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89234       };
89235     } catch (...) {
89236       {
89237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89238       };
89239     }
89240   }
89241 }
89242
89243
89244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89245   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89246   int arg2 ;
89247   std::vector< Dali::Actor > *arg3 = 0 ;
89248
89249   arg1 = (std::vector< Dali::Actor > *)jarg1;
89250   arg2 = (int)jarg2;
89251   arg3 = (std::vector< Dali::Actor > *)jarg3;
89252   if (!arg3) {
89253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89254     return ;
89255   }
89256   {
89257     try {
89258       try {
89259         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89260       }
89261       catch(std::out_of_range &_e) {
89262         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89263         return ;
89264       }
89265
89266     } catch (std::out_of_range& e) {
89267       {
89268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89269       };
89270     } catch (std::exception& e) {
89271       {
89272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89273       };
89274     } catch (...) {
89275       {
89276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89277       };
89278     }
89279   }
89280 }
89281
89282
89283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89284   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89285
89286   arg1 = (std::vector< Dali::Actor > *)jarg1;
89287   {
89288     try {
89289       delete arg1;
89290     } catch (std::out_of_range& e) {
89291       {
89292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89293       };
89294     } catch (std::exception& e) {
89295       {
89296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89301       };
89302     }
89303   }
89304 }
89305
89306
89307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89308   unsigned int jresult ;
89309   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89310   bool result;
89311
89312   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89313   {
89314     try {
89315       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89316     } catch (std::out_of_range& e) {
89317       {
89318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89319       };
89320     } catch (std::exception& e) {
89321       {
89322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89323       };
89324     } catch (...) {
89325       {
89326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89327       };
89328     }
89329   }
89330   jresult = result;
89331   return jresult;
89332 }
89333
89334
89335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89336   unsigned long jresult ;
89337   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89338   std::size_t result;
89339
89340   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89341   {
89342     try {
89343       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89344     } catch (std::out_of_range& e) {
89345       {
89346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89347       };
89348     } catch (std::exception& e) {
89349       {
89350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89351       };
89352     } catch (...) {
89353       {
89354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89355       };
89356     }
89357   }
89358   jresult = (unsigned long)result;
89359   return jresult;
89360 }
89361
89362
89363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89364   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89365   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89366
89367   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89368   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89369   {
89370     try {
89371       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89372     } catch (std::out_of_range& e) {
89373       {
89374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89375       };
89376     } catch (std::exception& e) {
89377       {
89378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89379       };
89380     } catch (...) {
89381       {
89382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89383       };
89384     }
89385   }
89386 }
89387
89388
89389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89390   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89391   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89392
89393   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89394   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89395   {
89396     try {
89397       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89398     } catch (std::out_of_range& e) {
89399       {
89400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89401       };
89402     } catch (std::exception& e) {
89403       {
89404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89405       };
89406     } catch (...) {
89407       {
89408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89409       };
89410     }
89411   }
89412 }
89413
89414
89415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89416   unsigned int jresult ;
89417   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89418   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89419   bool result;
89420
89421   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89422   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89423   if (!arg2) {
89424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89425     return 0;
89426   }
89427   {
89428     try {
89429       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89430     } catch (std::out_of_range& e) {
89431       {
89432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89433       };
89434     } catch (std::exception& e) {
89435       {
89436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89437       };
89438     } catch (...) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89441       };
89442     }
89443   }
89444   jresult = result;
89445   return jresult;
89446 }
89447
89448
89449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89450   void * jresult ;
89451   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89452
89453   {
89454     try {
89455       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89456     } catch (std::out_of_range& e) {
89457       {
89458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89459       };
89460     } catch (std::exception& e) {
89461       {
89462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89463       };
89464     } catch (...) {
89465       {
89466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89467       };
89468     }
89469   }
89470   jresult = (void *)result;
89471   return jresult;
89472 }
89473
89474
89475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89476   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89477
89478   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89479   {
89480     try {
89481       delete arg1;
89482     } catch (std::out_of_range& e) {
89483       {
89484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89485       };
89486     } catch (std::exception& e) {
89487       {
89488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89489       };
89490     } catch (...) {
89491       {
89492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89493       };
89494     }
89495   }
89496 }
89497
89498
89499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89500   unsigned int jresult ;
89501   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89502   bool result;
89503
89504   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89505   {
89506     try {
89507       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);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89515       };
89516     } catch (...) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89519       };
89520     }
89521   }
89522   jresult = result;
89523   return jresult;
89524 }
89525
89526
89527 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89528   unsigned long jresult ;
89529   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89530   std::size_t result;
89531
89532   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89533   {
89534     try {
89535       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);
89536     } catch (std::out_of_range& e) {
89537       {
89538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89539       };
89540     } catch (std::exception& e) {
89541       {
89542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89543       };
89544     } catch (...) {
89545       {
89546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89547       };
89548     }
89549   }
89550   jresult = (unsigned long)result;
89551   return jresult;
89552 }
89553
89554
89555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89556   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89557   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89558
89559   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89560   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89561   {
89562     try {
89563       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89564     } catch (std::out_of_range& e) {
89565       {
89566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89567       };
89568     } catch (std::exception& e) {
89569       {
89570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89571       };
89572     } catch (...) {
89573       {
89574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89575       };
89576     }
89577   }
89578 }
89579
89580
89581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89582   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89583   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89584
89585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89586   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89587   {
89588     try {
89589       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89590     } catch (std::out_of_range& e) {
89591       {
89592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89593       };
89594     } catch (std::exception& e) {
89595       {
89596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89597       };
89598     } catch (...) {
89599       {
89600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89601       };
89602     }
89603   }
89604 }
89605
89606
89607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89608   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89609   Dali::Actor arg2 ;
89610   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89611   Dali::Actor *argp2 ;
89612
89613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89614   argp2 = (Dali::Actor *)jarg2;
89615   if (!argp2) {
89616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89617     return ;
89618   }
89619   arg2 = *argp2;
89620   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89621   {
89622     try {
89623       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89624     } catch (std::out_of_range& e) {
89625       {
89626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89627       };
89628     } catch (std::exception& e) {
89629       {
89630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89631       };
89632     } catch (...) {
89633       {
89634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89635       };
89636     }
89637   }
89638 }
89639
89640
89641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89642   void * jresult ;
89643   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89644
89645   {
89646     try {
89647       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89648     } catch (std::out_of_range& e) {
89649       {
89650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89651       };
89652     } catch (std::exception& e) {
89653       {
89654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89655       };
89656     } catch (...) {
89657       {
89658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89659       };
89660     }
89661   }
89662   jresult = (void *)result;
89663   return jresult;
89664 }
89665
89666
89667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89668   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89669
89670   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89671   {
89672     try {
89673       delete arg1;
89674     } catch (std::out_of_range& e) {
89675       {
89676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89677       };
89678     } catch (std::exception& e) {
89679       {
89680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89681       };
89682     } catch (...) {
89683       {
89684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89685       };
89686     }
89687   }
89688 }
89689
89690
89691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89692   unsigned int jresult ;
89693   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89694   bool result;
89695
89696   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89697   {
89698     try {
89699       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89700     } catch (std::out_of_range& e) {
89701       {
89702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89703       };
89704     } catch (std::exception& e) {
89705       {
89706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89707       };
89708     } catch (...) {
89709       {
89710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89711       };
89712     }
89713   }
89714   jresult = result;
89715   return jresult;
89716 }
89717
89718
89719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89720   unsigned long jresult ;
89721   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89722   std::size_t result;
89723
89724   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89725   {
89726     try {
89727       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89728     } catch (std::out_of_range& e) {
89729       {
89730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89731       };
89732     } catch (std::exception& e) {
89733       {
89734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89735       };
89736     } catch (...) {
89737       {
89738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89739       };
89740     }
89741   }
89742   jresult = (unsigned long)result;
89743   return jresult;
89744 }
89745
89746
89747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89748   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89749   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89750
89751   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89752   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89753   {
89754     try {
89755       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89774   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89775   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89776
89777   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89778   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89779   {
89780     try {
89781       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89782     } catch (std::out_of_range& e) {
89783       {
89784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89785       };
89786     } catch (std::exception& e) {
89787       {
89788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89789       };
89790     } catch (...) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89793       };
89794     }
89795   }
89796 }
89797
89798
89799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89800   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89801   Dali::Actor arg2 ;
89802   Dali::Actor arg3 ;
89803   Dali::Actor *argp2 ;
89804   Dali::Actor *argp3 ;
89805
89806   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89807   argp2 = (Dali::Actor *)jarg2;
89808   if (!argp2) {
89809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89810     return ;
89811   }
89812   arg2 = *argp2;
89813   argp3 = (Dali::Actor *)jarg3;
89814   if (!argp3) {
89815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89816     return ;
89817   }
89818   arg3 = *argp3;
89819   {
89820     try {
89821       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89822     } catch (std::out_of_range& e) {
89823       {
89824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89825       };
89826     } catch (std::exception& e) {
89827       {
89828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89829       };
89830     } catch (...) {
89831       {
89832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89833       };
89834     }
89835   }
89836 }
89837
89838
89839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89840   void * jresult ;
89841   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89842
89843   {
89844     try {
89845       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89846     } catch (std::out_of_range& e) {
89847       {
89848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89849       };
89850     } catch (std::exception& e) {
89851       {
89852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89853       };
89854     } catch (...) {
89855       {
89856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89857       };
89858     }
89859   }
89860   jresult = (void *)result;
89861   return jresult;
89862 }
89863
89864
89865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89866   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89867
89868   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89869   {
89870     try {
89871       delete arg1;
89872     } catch (std::out_of_range& e) {
89873       {
89874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89875       };
89876     } catch (std::exception& e) {
89877       {
89878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89879       };
89880     } catch (...) {
89881       {
89882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89883       };
89884     }
89885   }
89886 }
89887
89888
89889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89890   unsigned int jresult ;
89891   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89892   bool result;
89893
89894   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89895   {
89896     try {
89897       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89898     } catch (std::out_of_range& e) {
89899       {
89900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89901       };
89902     } catch (std::exception& e) {
89903       {
89904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89905       };
89906     } catch (...) {
89907       {
89908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89909       };
89910     }
89911   }
89912   jresult = result;
89913   return jresult;
89914 }
89915
89916
89917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89918   unsigned long jresult ;
89919   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89920   std::size_t result;
89921
89922   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89923   {
89924     try {
89925       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89926     } catch (std::out_of_range& e) {
89927       {
89928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89929       };
89930     } catch (std::exception& e) {
89931       {
89932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89933       };
89934     } catch (...) {
89935       {
89936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89937       };
89938     }
89939   }
89940   jresult = (unsigned long)result;
89941   return jresult;
89942 }
89943
89944
89945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89946   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89947   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89948
89949   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89950   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89951   {
89952     try {
89953       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89954     } catch (std::out_of_range& e) {
89955       {
89956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89957       };
89958     } catch (std::exception& e) {
89959       {
89960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89961       };
89962     } catch (...) {
89963       {
89964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89965       };
89966     }
89967   }
89968 }
89969
89970
89971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89972   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89973   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89974
89975   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89976   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89977   {
89978     try {
89979       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89980     } catch (std::out_of_range& e) {
89981       {
89982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89983       };
89984     } catch (std::exception& e) {
89985       {
89986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89987       };
89988     } catch (...) {
89989       {
89990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89991       };
89992     }
89993   }
89994 }
89995
89996
89997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89998   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89999   Dali::Actor arg2 ;
90000   bool arg3 ;
90001   Dali::Actor *argp2 ;
90002
90003   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90004   argp2 = (Dali::Actor *)jarg2;
90005   if (!argp2) {
90006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90007     return ;
90008   }
90009   arg2 = *argp2;
90010   arg3 = jarg3 ? true : false;
90011   {
90012     try {
90013       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90014     } catch (std::out_of_range& e) {
90015       {
90016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90017       };
90018     } catch (std::exception& e) {
90019       {
90020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90021       };
90022     } catch (...) {
90023       {
90024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90025       };
90026     }
90027   }
90028 }
90029
90030
90031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90032   void * jresult ;
90033   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90034
90035   {
90036     try {
90037       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90038     } catch (std::out_of_range& e) {
90039       {
90040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90041       };
90042     } catch (std::exception& e) {
90043       {
90044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90045       };
90046     } catch (...) {
90047       {
90048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90049       };
90050     }
90051   }
90052   jresult = (void *)result;
90053   return jresult;
90054 }
90055
90056
90057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90058   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90059
90060   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90061   {
90062     try {
90063       delete arg1;
90064     } catch (std::out_of_range& e) {
90065       {
90066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90067       };
90068     } catch (std::exception& e) {
90069       {
90070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90075       };
90076     }
90077   }
90078 }
90079
90080
90081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90082   unsigned int jresult ;
90083   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90084   bool result;
90085
90086   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90087   {
90088     try {
90089       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);
90090     } catch (std::out_of_range& e) {
90091       {
90092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90093       };
90094     } catch (std::exception& e) {
90095       {
90096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90097       };
90098     } catch (...) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90101       };
90102     }
90103   }
90104   jresult = result;
90105   return jresult;
90106 }
90107
90108
90109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90110   unsigned long jresult ;
90111   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90112   std::size_t result;
90113
90114   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90115   {
90116     try {
90117       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);
90118     } catch (std::out_of_range& e) {
90119       {
90120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90121       };
90122     } catch (std::exception& e) {
90123       {
90124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90125       };
90126     } catch (...) {
90127       {
90128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90129       };
90130     }
90131   }
90132   jresult = (unsigned long)result;
90133   return jresult;
90134 }
90135
90136
90137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90138   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90139   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90140
90141   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90142   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90143   {
90144     try {
90145       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90146     } catch (std::out_of_range& e) {
90147       {
90148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90149       };
90150     } catch (std::exception& e) {
90151       {
90152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90153       };
90154     } catch (...) {
90155       {
90156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90157       };
90158     }
90159   }
90160 }
90161
90162
90163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90164   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90165   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90166
90167   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90168   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90169   {
90170     try {
90171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90172     } catch (std::out_of_range& e) {
90173       {
90174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90175       };
90176     } catch (std::exception& e) {
90177       {
90178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90179       };
90180     } catch (...) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90183       };
90184     }
90185   }
90186 }
90187
90188
90189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90190   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90191   Dali::Toolkit::StyleManager arg2 ;
90192   Dali::StyleChange::Type arg3 ;
90193   Dali::Toolkit::StyleManager *argp2 ;
90194
90195   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90196   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90197   if (!argp2) {
90198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90199     return ;
90200   }
90201   arg2 = *argp2;
90202   arg3 = (Dali::StyleChange::Type)jarg3;
90203   {
90204     try {
90205       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90206     } catch (std::out_of_range& e) {
90207       {
90208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90209       };
90210     } catch (std::exception& e) {
90211       {
90212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90213       };
90214     } catch (...) {
90215       {
90216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90217       };
90218     }
90219   }
90220 }
90221
90222
90223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90224   void * jresult ;
90225   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90226
90227   {
90228     try {
90229       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90230     } catch (std::out_of_range& e) {
90231       {
90232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90233       };
90234     } catch (std::exception& e) {
90235       {
90236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90237       };
90238     } catch (...) {
90239       {
90240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90241       };
90242     }
90243   }
90244   jresult = (void *)result;
90245   return jresult;
90246 }
90247
90248
90249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90250   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90251
90252   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90253   {
90254     try {
90255       delete arg1;
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90263       };
90264     } catch (...) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90267       };
90268     }
90269   }
90270 }
90271
90272
90273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90274   unsigned int jresult ;
90275   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90276   bool result;
90277
90278   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90279   {
90280     try {
90281       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
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 unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90302   unsigned long jresult ;
90303   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90304   std::size_t result;
90305
90306   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90307   {
90308     try {
90309       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90310     } catch (std::out_of_range& e) {
90311       {
90312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90313       };
90314     } catch (std::exception& e) {
90315       {
90316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90317       };
90318     } catch (...) {
90319       {
90320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90321       };
90322     }
90323   }
90324   jresult = (unsigned long)result;
90325   return jresult;
90326 }
90327
90328
90329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90330   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90331   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90332
90333   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90334   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90335   {
90336     try {
90337       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90338     } catch (std::out_of_range& e) {
90339       {
90340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90341       };
90342     } catch (std::exception& e) {
90343       {
90344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (...) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90349       };
90350     }
90351   }
90352 }
90353
90354
90355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90356   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90357   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90358
90359   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90360   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90361   {
90362     try {
90363       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90364     } catch (std::out_of_range& e) {
90365       {
90366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90367       };
90368     } catch (std::exception& e) {
90369       {
90370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90371       };
90372     } catch (...) {
90373       {
90374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90375       };
90376     }
90377   }
90378 }
90379
90380
90381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90382   unsigned int jresult ;
90383   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90384   Dali::Toolkit::Button arg2 ;
90385   Dali::Toolkit::Button *argp2 ;
90386   bool result;
90387
90388   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90389   argp2 = (Dali::Toolkit::Button *)jarg2;
90390   if (!argp2) {
90391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90392     return 0;
90393   }
90394   arg2 = *argp2;
90395   {
90396     try {
90397       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90398     } catch (std::out_of_range& e) {
90399       {
90400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (std::exception& e) {
90403       {
90404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90405       };
90406     } catch (...) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90409       };
90410     }
90411   }
90412   jresult = result;
90413   return jresult;
90414 }
90415
90416
90417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90418   void * jresult ;
90419   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90420
90421   {
90422     try {
90423       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90424     } catch (std::out_of_range& e) {
90425       {
90426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (std::exception& e) {
90429       {
90430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (...) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90435       };
90436     }
90437   }
90438   jresult = (void *)result;
90439   return jresult;
90440 }
90441
90442
90443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90444   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90445
90446   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90447   {
90448     try {
90449       delete arg1;
90450     } catch (std::out_of_range& e) {
90451       {
90452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90453       };
90454     } catch (std::exception& e) {
90455       {
90456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90457       };
90458     } catch (...) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90461       };
90462     }
90463   }
90464 }
90465
90466
90467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90468   unsigned int jresult ;
90469   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90470   bool result;
90471
90472   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90473   {
90474     try {
90475       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90476     } catch (std::out_of_range& e) {
90477       {
90478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90479       };
90480     } catch (std::exception& e) {
90481       {
90482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (...) {
90485       {
90486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90487       };
90488     }
90489   }
90490   jresult = result;
90491   return jresult;
90492 }
90493
90494
90495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90496   unsigned long jresult ;
90497   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90498   std::size_t result;
90499
90500   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90501   {
90502     try {
90503       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90504     } catch (std::out_of_range& e) {
90505       {
90506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90507       };
90508     } catch (std::exception& e) {
90509       {
90510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (...) {
90513       {
90514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90515       };
90516     }
90517   }
90518   jresult = (unsigned long)result;
90519   return jresult;
90520 }
90521
90522
90523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90524   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90525   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90526
90527   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90528   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90529   {
90530     try {
90531       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90532     } catch (std::out_of_range& e) {
90533       {
90534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90535       };
90536     } catch (std::exception& e) {
90537       {
90538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90539       };
90540     } catch (...) {
90541       {
90542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90543       };
90544     }
90545   }
90546 }
90547
90548
90549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90550   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90551   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90552
90553   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90554   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90555   {
90556     try {
90557       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90558     } catch (std::out_of_range& e) {
90559       {
90560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90561       };
90562     } catch (std::exception& e) {
90563       {
90564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90565       };
90566     } catch (...) {
90567       {
90568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90569       };
90570     }
90571   }
90572 }
90573
90574
90575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90576   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90577   Dali::Toolkit::GaussianBlurView arg2 ;
90578   Dali::Toolkit::GaussianBlurView *argp2 ;
90579
90580   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90581   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90582   if (!argp2) {
90583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90584     return ;
90585   }
90586   arg2 = *argp2;
90587   {
90588     try {
90589       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90590     } catch (std::out_of_range& e) {
90591       {
90592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90593       };
90594     } catch (std::exception& e) {
90595       {
90596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90597       };
90598     } catch (...) {
90599       {
90600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90601       };
90602     }
90603   }
90604 }
90605
90606
90607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90608   void * jresult ;
90609   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90610
90611   {
90612     try {
90613       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90614     } catch (std::out_of_range& e) {
90615       {
90616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90617       };
90618     } catch (std::exception& e) {
90619       {
90620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (...) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90625       };
90626     }
90627   }
90628   jresult = (void *)result;
90629   return jresult;
90630 }
90631
90632
90633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90634   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90635
90636   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90637   {
90638     try {
90639       delete arg1;
90640     } catch (std::out_of_range& e) {
90641       {
90642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90643       };
90644     } catch (std::exception& e) {
90645       {
90646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90647       };
90648     } catch (...) {
90649       {
90650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90651       };
90652     }
90653   }
90654 }
90655
90656
90657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90658   unsigned int jresult ;
90659   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90660   bool result;
90661
90662   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90663   {
90664     try {
90665       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);
90666     } catch (std::out_of_range& e) {
90667       {
90668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90669       };
90670     } catch (std::exception& e) {
90671       {
90672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90673       };
90674     } catch (...) {
90675       {
90676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90677       };
90678     }
90679   }
90680   jresult = result;
90681   return jresult;
90682 }
90683
90684
90685 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90686   unsigned long jresult ;
90687   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90688   std::size_t result;
90689
90690   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90691   {
90692     try {
90693       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);
90694     } catch (std::out_of_range& e) {
90695       {
90696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90697       };
90698     } catch (std::exception& e) {
90699       {
90700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90701       };
90702     } catch (...) {
90703       {
90704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90705       };
90706     }
90707   }
90708   jresult = (unsigned long)result;
90709   return jresult;
90710 }
90711
90712
90713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90714   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90715   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90716
90717   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90718   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90719   {
90720     try {
90721       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90722     } catch (std::out_of_range& e) {
90723       {
90724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90725       };
90726     } catch (std::exception& e) {
90727       {
90728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90729       };
90730     } catch (...) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90733       };
90734     }
90735   }
90736 }
90737
90738
90739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90740   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90741   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90742
90743   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90744   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90745   {
90746     try {
90747       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90748     } catch (std::out_of_range& e) {
90749       {
90750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90751       };
90752     } catch (std::exception& e) {
90753       {
90754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90755       };
90756     } catch (...) {
90757       {
90758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90759       };
90760     }
90761   }
90762 }
90763
90764
90765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90766   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90767   Dali::Toolkit::PageTurnView arg2 ;
90768   unsigned int arg3 ;
90769   bool arg4 ;
90770   Dali::Toolkit::PageTurnView *argp2 ;
90771
90772   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90773   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90774   if (!argp2) {
90775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90776     return ;
90777   }
90778   arg2 = *argp2;
90779   arg3 = (unsigned int)jarg3;
90780   arg4 = jarg4 ? true : false;
90781   {
90782     try {
90783       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90784     } catch (std::out_of_range& e) {
90785       {
90786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90787       };
90788     } catch (std::exception& e) {
90789       {
90790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90791       };
90792     } catch (...) {
90793       {
90794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90795       };
90796     }
90797   }
90798 }
90799
90800
90801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90802   void * jresult ;
90803   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90804
90805   {
90806     try {
90807       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90808     } catch (std::out_of_range& e) {
90809       {
90810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90811       };
90812     } catch (std::exception& e) {
90813       {
90814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90815       };
90816     } catch (...) {
90817       {
90818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90819       };
90820     }
90821   }
90822   jresult = (void *)result;
90823   return jresult;
90824 }
90825
90826
90827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90828   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90829
90830   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90831   {
90832     try {
90833       delete arg1;
90834     } catch (std::out_of_range& e) {
90835       {
90836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90837       };
90838     } catch (std::exception& e) {
90839       {
90840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90841       };
90842     } catch (...) {
90843       {
90844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90845       };
90846     }
90847   }
90848 }
90849
90850
90851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90852   unsigned int jresult ;
90853   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90854   bool result;
90855
90856   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90857   {
90858     try {
90859       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90860     } catch (std::out_of_range& e) {
90861       {
90862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (std::exception& e) {
90865       {
90866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90871       };
90872     }
90873   }
90874   jresult = result;
90875   return jresult;
90876 }
90877
90878
90879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90880   unsigned long jresult ;
90881   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90882   std::size_t result;
90883
90884   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90885   {
90886     try {
90887       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90888     } catch (std::out_of_range& e) {
90889       {
90890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90891       };
90892     } catch (std::exception& e) {
90893       {
90894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90895       };
90896     } catch (...) {
90897       {
90898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90899       };
90900     }
90901   }
90902   jresult = (unsigned long)result;
90903   return jresult;
90904 }
90905
90906
90907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90908   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90909   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90910
90911   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90912   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90913   {
90914     try {
90915       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90916     } catch (std::out_of_range& e) {
90917       {
90918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90919       };
90920     } catch (std::exception& e) {
90921       {
90922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90923       };
90924     } catch (...) {
90925       {
90926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90927       };
90928     }
90929   }
90930 }
90931
90932
90933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90934   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90935   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90936
90937   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90938   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90939   {
90940     try {
90941       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90942     } catch (std::out_of_range& e) {
90943       {
90944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90945       };
90946     } catch (std::exception& e) {
90947       {
90948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90949       };
90950     } catch (...) {
90951       {
90952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90953       };
90954     }
90955   }
90956 }
90957
90958
90959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90960   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90961   Dali::Toolkit::PageTurnView arg2 ;
90962   Dali::Toolkit::PageTurnView *argp2 ;
90963
90964   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90965   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90966   if (!argp2) {
90967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90968     return ;
90969   }
90970   arg2 = *argp2;
90971   {
90972     try {
90973       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90981       };
90982     } catch (...) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90985       };
90986     }
90987   }
90988 }
90989
90990
90991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90992   void * jresult ;
90993   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90994
90995   {
90996     try {
90997       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90998     } catch (std::out_of_range& e) {
90999       {
91000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91001       };
91002     } catch (std::exception& e) {
91003       {
91004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91005       };
91006     } catch (...) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91009       };
91010     }
91011   }
91012   jresult = (void *)result;
91013   return jresult;
91014 }
91015
91016
91017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91018   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91019
91020   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91021   {
91022     try {
91023       delete arg1;
91024     } catch (std::out_of_range& e) {
91025       {
91026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91027       };
91028     } catch (std::exception& e) {
91029       {
91030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91031       };
91032     } catch (...) {
91033       {
91034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91035       };
91036     }
91037   }
91038 }
91039
91040
91041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91042   unsigned int jresult ;
91043   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91044   bool result;
91045
91046   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91047   {
91048     try {
91049       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);
91050     } catch (std::out_of_range& e) {
91051       {
91052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91053       };
91054     } catch (std::exception& e) {
91055       {
91056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91061       };
91062     }
91063   }
91064   jresult = result;
91065   return jresult;
91066 }
91067
91068
91069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91070   unsigned long jresult ;
91071   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91072   std::size_t result;
91073
91074   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91075   {
91076     try {
91077       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);
91078     } catch (std::out_of_range& e) {
91079       {
91080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (std::exception& e) {
91083       {
91084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91089       };
91090     }
91091   }
91092   jresult = (unsigned long)result;
91093   return jresult;
91094 }
91095
91096
91097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91098   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91099   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91100
91101   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91102   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91103   {
91104     try {
91105       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91106     } catch (std::out_of_range& e) {
91107       {
91108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91109       };
91110     } catch (std::exception& e) {
91111       {
91112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91113       };
91114     } catch (...) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91117       };
91118     }
91119   }
91120 }
91121
91122
91123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91124   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91125   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91126
91127   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91128   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91129   {
91130     try {
91131       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91132     } catch (std::out_of_range& e) {
91133       {
91134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91135       };
91136     } catch (std::exception& e) {
91137       {
91138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91139       };
91140     } catch (...) {
91141       {
91142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91143       };
91144     }
91145   }
91146 }
91147
91148
91149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91150   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91151   Dali::Toolkit::ProgressBar arg2 ;
91152   float arg3 ;
91153   float arg4 ;
91154   Dali::Toolkit::ProgressBar *argp2 ;
91155
91156   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91157   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91158   if (!argp2) {
91159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91160     return ;
91161   }
91162   arg2 = *argp2;
91163   arg3 = (float)jarg3;
91164   arg4 = (float)jarg4;
91165   {
91166     try {
91167       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91168     } catch (std::out_of_range& e) {
91169       {
91170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91171       };
91172     } catch (std::exception& e) {
91173       {
91174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91175       };
91176     } catch (...) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91179       };
91180     }
91181   }
91182 }
91183
91184
91185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91186   void * jresult ;
91187   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91188
91189   {
91190     try {
91191       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91192     } catch (std::out_of_range& e) {
91193       {
91194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91195       };
91196     } catch (std::exception& e) {
91197       {
91198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91199       };
91200     } catch (...) {
91201       {
91202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91203       };
91204     }
91205   }
91206   jresult = (void *)result;
91207   return jresult;
91208 }
91209
91210
91211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91212   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91213
91214   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91215   {
91216     try {
91217       delete arg1;
91218     } catch (std::out_of_range& e) {
91219       {
91220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91221       };
91222     } catch (std::exception& e) {
91223       {
91224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91229       };
91230     }
91231   }
91232 }
91233
91234
91235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91236   unsigned int jresult ;
91237   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91238   bool result;
91239
91240   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91241   {
91242     try {
91243       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);
91244     } catch (std::out_of_range& e) {
91245       {
91246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91247       };
91248     } catch (std::exception& e) {
91249       {
91250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91251       };
91252     } catch (...) {
91253       {
91254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91255       };
91256     }
91257   }
91258   jresult = result;
91259   return jresult;
91260 }
91261
91262
91263 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91264   unsigned long jresult ;
91265   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91266   std::size_t result;
91267
91268   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91269   {
91270     try {
91271       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);
91272     } catch (std::out_of_range& e) {
91273       {
91274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91275       };
91276     } catch (std::exception& e) {
91277       {
91278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91279       };
91280     } catch (...) {
91281       {
91282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91283       };
91284     }
91285   }
91286   jresult = (unsigned long)result;
91287   return jresult;
91288 }
91289
91290
91291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91292   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91293   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91294
91295   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91296   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91297   {
91298     try {
91299       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91300     } catch (std::out_of_range& e) {
91301       {
91302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91303       };
91304     } catch (std::exception& e) {
91305       {
91306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91307       };
91308     } catch (...) {
91309       {
91310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91311       };
91312     }
91313   }
91314 }
91315
91316
91317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91318   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91319   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91320
91321   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91322   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91323   {
91324     try {
91325       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91326     } catch (std::out_of_range& e) {
91327       {
91328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91329       };
91330     } catch (std::exception& e) {
91331       {
91332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91333       };
91334     } catch (...) {
91335       {
91336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91337       };
91338     }
91339   }
91340 }
91341
91342
91343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91344   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91345   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91346
91347   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91348   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91349   if (!arg2) {
91350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91351     return ;
91352   }
91353   {
91354     try {
91355       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91356     } catch (std::out_of_range& e) {
91357       {
91358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91359       };
91360     } catch (std::exception& e) {
91361       {
91362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91363       };
91364     } catch (...) {
91365       {
91366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91367       };
91368     }
91369   }
91370 }
91371
91372
91373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91374   void * jresult ;
91375   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91376
91377   {
91378     try {
91379       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91380     } catch (std::out_of_range& e) {
91381       {
91382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91383       };
91384     } catch (std::exception& e) {
91385       {
91386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91387       };
91388     } catch (...) {
91389       {
91390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91391       };
91392     }
91393   }
91394   jresult = (void *)result;
91395   return jresult;
91396 }
91397
91398
91399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91400   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91401
91402   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91403   {
91404     try {
91405       delete arg1;
91406     } catch (std::out_of_range& e) {
91407       {
91408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91409       };
91410     } catch (std::exception& e) {
91411       {
91412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91413       };
91414     } catch (...) {
91415       {
91416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91417       };
91418     }
91419   }
91420 }
91421
91422
91423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91424   unsigned int jresult ;
91425   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91426   bool result;
91427
91428   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91429   {
91430     try {
91431       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91432     } catch (std::out_of_range& e) {
91433       {
91434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91435       };
91436     } catch (std::exception& e) {
91437       {
91438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91439       };
91440     } catch (...) {
91441       {
91442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91443       };
91444     }
91445   }
91446   jresult = result;
91447   return jresult;
91448 }
91449
91450
91451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91452   unsigned long jresult ;
91453   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91454   std::size_t result;
91455
91456   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91457   {
91458     try {
91459       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91460     } catch (std::out_of_range& e) {
91461       {
91462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (std::exception& e) {
91465       {
91466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91467       };
91468     } catch (...) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91471       };
91472     }
91473   }
91474   jresult = (unsigned long)result;
91475   return jresult;
91476 }
91477
91478
91479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91480   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91481   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91482
91483   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91484   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91485   {
91486     try {
91487       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91488     } catch (std::out_of_range& e) {
91489       {
91490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91491       };
91492     } catch (std::exception& e) {
91493       {
91494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91495       };
91496     } catch (...) {
91497       {
91498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91499       };
91500     }
91501   }
91502 }
91503
91504
91505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91506   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91507   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91508
91509   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91510   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91511   {
91512     try {
91513       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91514     } catch (std::out_of_range& e) {
91515       {
91516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91517       };
91518     } catch (std::exception& e) {
91519       {
91520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91521       };
91522     } catch (...) {
91523       {
91524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91525       };
91526     }
91527   }
91528 }
91529
91530
91531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91532   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91533   Dali::Vector2 *arg2 = 0 ;
91534
91535   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91536   arg2 = (Dali::Vector2 *)jarg2;
91537   if (!arg2) {
91538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91539     return ;
91540   }
91541   {
91542     try {
91543       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91544     } catch (std::out_of_range& e) {
91545       {
91546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (std::exception& e) {
91549       {
91550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91551       };
91552     } catch (...) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91555       };
91556     }
91557   }
91558 }
91559
91560
91561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91562   void * jresult ;
91563   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91564
91565   {
91566     try {
91567       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91568     } catch (std::out_of_range& e) {
91569       {
91570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91571       };
91572     } catch (std::exception& e) {
91573       {
91574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91575       };
91576     } catch (...) {
91577       {
91578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91579       };
91580     }
91581   }
91582   jresult = (void *)result;
91583   return jresult;
91584 }
91585
91586
91587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91588   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91589
91590   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91591   {
91592     try {
91593       delete arg1;
91594     } catch (std::out_of_range& e) {
91595       {
91596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91597       };
91598     } catch (std::exception& e) {
91599       {
91600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91601       };
91602     } catch (...) {
91603       {
91604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91605       };
91606     }
91607   }
91608 }
91609
91610
91611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91612   unsigned int jresult ;
91613   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91614   bool result;
91615
91616   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91617   {
91618     try {
91619       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91620     } catch (std::out_of_range& e) {
91621       {
91622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91623       };
91624     } catch (std::exception& e) {
91625       {
91626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91627       };
91628     } catch (...) {
91629       {
91630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91631       };
91632     }
91633   }
91634   jresult = result;
91635   return jresult;
91636 }
91637
91638
91639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91640   unsigned long jresult ;
91641   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91642   std::size_t result;
91643
91644   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91645   {
91646     try {
91647       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91655       };
91656     } catch (...) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91659       };
91660     }
91661   }
91662   jresult = (unsigned long)result;
91663   return jresult;
91664 }
91665
91666
91667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91668   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91669   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91670
91671   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91672   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91673   {
91674     try {
91675       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91676     } catch (std::out_of_range& e) {
91677       {
91678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91679       };
91680     } catch (std::exception& e) {
91681       {
91682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91683       };
91684     } catch (...) {
91685       {
91686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91687       };
91688     }
91689   }
91690 }
91691
91692
91693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91694   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91695   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91696
91697   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91698   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91699   {
91700     try {
91701       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91702     } catch (std::out_of_range& e) {
91703       {
91704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91705       };
91706     } catch (std::exception& e) {
91707       {
91708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91709       };
91710     } catch (...) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91713       };
91714     }
91715   }
91716 }
91717
91718
91719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91720   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91721   Dali::Toolkit::TextEditor arg2 ;
91722   Dali::Toolkit::TextEditor *argp2 ;
91723
91724   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91725   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91726   if (!argp2) {
91727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91728     return ;
91729   }
91730   arg2 = *argp2;
91731   {
91732     try {
91733       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91734     } catch (std::out_of_range& e) {
91735       {
91736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91737       };
91738     } catch (std::exception& e) {
91739       {
91740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91741       };
91742     } catch (...) {
91743       {
91744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91745       };
91746     }
91747   }
91748 }
91749
91750
91751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91752   void * jresult ;
91753   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91754
91755   {
91756     try {
91757       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91758     } catch (std::out_of_range& e) {
91759       {
91760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91761       };
91762     } catch (std::exception& e) {
91763       {
91764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91765       };
91766     } catch (...) {
91767       {
91768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91769       };
91770     }
91771   }
91772   jresult = (void *)result;
91773   return jresult;
91774 }
91775
91776
91777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91778   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91779
91780   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91781   {
91782     try {
91783       delete arg1;
91784     } catch (std::out_of_range& e) {
91785       {
91786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91787       };
91788     } catch (std::exception& e) {
91789       {
91790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91791       };
91792     } catch (...) {
91793       {
91794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91795       };
91796     }
91797   }
91798 }
91799
91800
91801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91802   unsigned int jresult ;
91803   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91804   bool result;
91805
91806   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91807   {
91808     try {
91809       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91810     } catch (std::out_of_range& e) {
91811       {
91812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91813       };
91814     } catch (std::exception& e) {
91815       {
91816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91817       };
91818     } catch (...) {
91819       {
91820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91821       };
91822     }
91823   }
91824   jresult = result;
91825   return jresult;
91826 }
91827
91828
91829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91830   unsigned long jresult ;
91831   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91832   std::size_t result;
91833
91834   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91835   {
91836     try {
91837       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91838     } catch (std::out_of_range& e) {
91839       {
91840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91841       };
91842     } catch (std::exception& e) {
91843       {
91844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91845       };
91846     } catch (...) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91849       };
91850     }
91851   }
91852   jresult = (unsigned long)result;
91853   return jresult;
91854 }
91855
91856
91857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91858   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91859   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91860
91861   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91862   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91863   {
91864     try {
91865       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91873       };
91874     } catch (...) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91877       };
91878     }
91879   }
91880 }
91881
91882
91883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91884   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91885   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91886
91887   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91888   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91889   {
91890     try {
91891       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91892     } catch (std::out_of_range& e) {
91893       {
91894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91895       };
91896     } catch (std::exception& e) {
91897       {
91898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91899       };
91900     } catch (...) {
91901       {
91902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91903       };
91904     }
91905   }
91906 }
91907
91908
91909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91910   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91911   Dali::Toolkit::TextField arg2 ;
91912   Dali::Toolkit::TextField *argp2 ;
91913
91914   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91915   argp2 = (Dali::Toolkit::TextField *)jarg2;
91916   if (!argp2) {
91917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91918     return ;
91919   }
91920   arg2 = *argp2;
91921   {
91922     try {
91923       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91924     } catch (std::out_of_range& e) {
91925       {
91926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91927       };
91928     } catch (std::exception& e) {
91929       {
91930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91931       };
91932     } catch (...) {
91933       {
91934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91935       };
91936     }
91937   }
91938 }
91939
91940
91941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91942   void * jresult ;
91943   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91944
91945   {
91946     try {
91947       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91948     } catch (std::out_of_range& e) {
91949       {
91950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91951       };
91952     } catch (std::exception& e) {
91953       {
91954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91955       };
91956     } catch (...) {
91957       {
91958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91959       };
91960     }
91961   }
91962   jresult = (void *)result;
91963   return jresult;
91964 }
91965
91966
91967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91968   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91969
91970   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91971   {
91972     try {
91973       delete arg1;
91974     } catch (std::out_of_range& e) {
91975       {
91976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91977       };
91978     } catch (std::exception& e) {
91979       {
91980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91981       };
91982     } catch (...) {
91983       {
91984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91985       };
91986     }
91987   }
91988 }
91989
91990
91991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91992   unsigned int jresult ;
91993   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91994   bool result;
91995
91996   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91997   {
91998     try {
91999       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);
92000     } catch (std::out_of_range& e) {
92001       {
92002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92003       };
92004     } catch (std::exception& e) {
92005       {
92006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92007       };
92008     } catch (...) {
92009       {
92010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92011       };
92012     }
92013   }
92014   jresult = result;
92015   return jresult;
92016 }
92017
92018
92019 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92020   unsigned long jresult ;
92021   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92022   std::size_t result;
92023
92024   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92025   {
92026     try {
92027       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);
92028     } catch (std::out_of_range& e) {
92029       {
92030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92031       };
92032     } catch (std::exception& e) {
92033       {
92034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92035       };
92036     } catch (...) {
92037       {
92038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92039       };
92040     }
92041   }
92042   jresult = (unsigned long)result;
92043   return jresult;
92044 }
92045
92046
92047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92048   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92049   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92050
92051   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92052   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92053   {
92054     try {
92055       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92056     } catch (std::out_of_range& e) {
92057       {
92058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92059       };
92060     } catch (std::exception& e) {
92061       {
92062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92063       };
92064     } catch (...) {
92065       {
92066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92067       };
92068     }
92069   }
92070 }
92071
92072
92073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92074   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92075   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92076
92077   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92078   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92079   {
92080     try {
92081       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92082     } catch (std::out_of_range& e) {
92083       {
92084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92085       };
92086     } catch (std::exception& e) {
92087       {
92088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92089       };
92090     } catch (...) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92093       };
92094     }
92095   }
92096 }
92097
92098
92099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92100   unsigned int jresult ;
92101   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92102   Dali::Toolkit::Control arg2 ;
92103   Dali::KeyEvent *arg3 = 0 ;
92104   Dali::Toolkit::Control *argp2 ;
92105   bool result;
92106
92107   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92108   argp2 = (Dali::Toolkit::Control *)jarg2;
92109   if (!argp2) {
92110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92111     return 0;
92112   }
92113   arg2 = *argp2;
92114   arg3 = (Dali::KeyEvent *)jarg3;
92115   if (!arg3) {
92116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92117     return 0;
92118   }
92119   {
92120     try {
92121       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);
92122     } catch (std::out_of_range& e) {
92123       {
92124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92125       };
92126     } catch (std::exception& e) {
92127       {
92128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92129       };
92130     } catch (...) {
92131       {
92132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92133       };
92134     }
92135   }
92136   jresult = result;
92137   return jresult;
92138 }
92139
92140
92141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92142   void * jresult ;
92143   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92144
92145   {
92146     try {
92147       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92148     } catch (std::out_of_range& e) {
92149       {
92150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92151       };
92152     } catch (std::exception& e) {
92153       {
92154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92155       };
92156     } catch (...) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92159       };
92160     }
92161   }
92162   jresult = (void *)result;
92163   return jresult;
92164 }
92165
92166
92167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92168   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92169
92170   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92171   {
92172     try {
92173       delete arg1;
92174     } catch (std::out_of_range& e) {
92175       {
92176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92177       };
92178     } catch (std::exception& e) {
92179       {
92180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92181       };
92182     } catch (...) {
92183       {
92184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92185       };
92186     }
92187   }
92188 }
92189
92190
92191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92192   unsigned int jresult ;
92193   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92194   bool result;
92195
92196   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92197   {
92198     try {
92199       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92200     } catch (std::out_of_range& e) {
92201       {
92202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92203       };
92204     } catch (std::exception& e) {
92205       {
92206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92207       };
92208     } catch (...) {
92209       {
92210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92211       };
92212     }
92213   }
92214   jresult = result;
92215   return jresult;
92216 }
92217
92218
92219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92220   unsigned long jresult ;
92221   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92222   std::size_t result;
92223
92224   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92225   {
92226     try {
92227       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92228     } catch (std::out_of_range& e) {
92229       {
92230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92231       };
92232     } catch (std::exception& e) {
92233       {
92234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92235       };
92236     } catch (...) {
92237       {
92238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92239       };
92240     }
92241   }
92242   jresult = (unsigned long)result;
92243   return jresult;
92244 }
92245
92246
92247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92248   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92249   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92250
92251   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92252   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92253   {
92254     try {
92255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92256     } catch (std::out_of_range& e) {
92257       {
92258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92259       };
92260     } catch (std::exception& e) {
92261       {
92262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92263       };
92264     } catch (...) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92267       };
92268     }
92269   }
92270 }
92271
92272
92273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92274   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92275   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92276
92277   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92278   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92279   {
92280     try {
92281       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92282     } catch (std::out_of_range& e) {
92283       {
92284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92285       };
92286     } catch (std::exception& e) {
92287       {
92288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92289       };
92290     } catch (...) {
92291       {
92292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92293       };
92294     }
92295   }
92296 }
92297
92298
92299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92300   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92301   Dali::Toolkit::Control arg2 ;
92302   Dali::Toolkit::Control *argp2 ;
92303
92304   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92305   argp2 = (Dali::Toolkit::Control *)jarg2;
92306   if (!argp2) {
92307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92308     return ;
92309   }
92310   arg2 = *argp2;
92311   {
92312     try {
92313       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92314     } catch (std::out_of_range& e) {
92315       {
92316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92317       };
92318     } catch (std::exception& e) {
92319       {
92320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92321       };
92322     } catch (...) {
92323       {
92324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92325       };
92326     }
92327   }
92328 }
92329
92330
92331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92332   void * jresult ;
92333   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92334
92335   {
92336     try {
92337       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (...) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92349       };
92350     }
92351   }
92352   jresult = (void *)result;
92353   return jresult;
92354 }
92355
92356
92357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92358   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92359
92360   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92361   {
92362     try {
92363       delete arg1;
92364     } catch (std::out_of_range& e) {
92365       {
92366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92367       };
92368     } catch (std::exception& e) {
92369       {
92370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92371       };
92372     } catch (...) {
92373       {
92374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92375       };
92376     }
92377   }
92378 }
92379
92380
92381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92382   unsigned int jresult ;
92383   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92384   bool result;
92385
92386   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92387   {
92388     try {
92389       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92390     } catch (std::out_of_range& e) {
92391       {
92392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92393       };
92394     } catch (std::exception& e) {
92395       {
92396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92397       };
92398     } catch (...) {
92399       {
92400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92401       };
92402     }
92403   }
92404   jresult = result;
92405   return jresult;
92406 }
92407
92408
92409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92410   unsigned long jresult ;
92411   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92412   std::size_t result;
92413
92414   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92415   {
92416     try {
92417       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92418     } catch (std::out_of_range& e) {
92419       {
92420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92421       };
92422     } catch (std::exception& e) {
92423       {
92424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92425       };
92426     } catch (...) {
92427       {
92428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92429       };
92430     }
92431   }
92432   jresult = (unsigned long)result;
92433   return jresult;
92434 }
92435
92436
92437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92438   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92439   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92440
92441   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92442   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92443   {
92444     try {
92445       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92446     } catch (std::out_of_range& e) {
92447       {
92448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92449       };
92450     } catch (std::exception& e) {
92451       {
92452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92453       };
92454     } catch (...) {
92455       {
92456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92457       };
92458     }
92459   }
92460 }
92461
92462
92463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92464   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92465   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92466
92467   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92468   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92469   {
92470     try {
92471       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92479       };
92480     } catch (...) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92483       };
92484     }
92485   }
92486 }
92487
92488
92489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92490   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92491   Dali::Toolkit::VideoView *arg2 = 0 ;
92492
92493   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92494   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92495   if (!arg2) {
92496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92497     return ;
92498   }
92499   {
92500     try {
92501       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92502     } catch (std::out_of_range& e) {
92503       {
92504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92505       };
92506     } catch (std::exception& e) {
92507       {
92508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92509       };
92510     } catch (...) {
92511       {
92512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92513       };
92514     }
92515   }
92516 }
92517
92518
92519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92520   void * jresult ;
92521   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92522
92523   {
92524     try {
92525       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92526     } catch (std::out_of_range& e) {
92527       {
92528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92529       };
92530     } catch (std::exception& e) {
92531       {
92532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92533       };
92534     } catch (...) {
92535       {
92536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92537       };
92538     }
92539   }
92540   jresult = (void *)result;
92541   return jresult;
92542 }
92543
92544
92545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92546   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92547
92548   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92549   {
92550     try {
92551       delete arg1;
92552     } catch (std::out_of_range& e) {
92553       {
92554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92555       };
92556     } catch (std::exception& e) {
92557       {
92558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92559       };
92560     } catch (...) {
92561       {
92562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92563       };
92564     }
92565   }
92566 }
92567
92568
92569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92570   unsigned int jresult ;
92571   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92572   bool result;
92573
92574   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92575   {
92576     try {
92577       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92578     } catch (std::out_of_range& e) {
92579       {
92580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92581       };
92582     } catch (std::exception& e) {
92583       {
92584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (...) {
92587       {
92588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92589       };
92590     }
92591   }
92592   jresult = result;
92593   return jresult;
92594 }
92595
92596
92597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92598   unsigned long jresult ;
92599   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92600   std::size_t result;
92601
92602   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92603   {
92604     try {
92605       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
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 = (unsigned long)result;
92621   return jresult;
92622 }
92623
92624
92625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92626   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92627   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92628
92629   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92630   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92631   {
92632     try {
92633       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92634     } catch (std::out_of_range& e) {
92635       {
92636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92637       };
92638     } catch (std::exception& e) {
92639       {
92640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92641       };
92642     } catch (...) {
92643       {
92644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92645       };
92646     }
92647   }
92648 }
92649
92650
92651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92652   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92653   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92654
92655   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92656   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92657   {
92658     try {
92659       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92660     } catch (std::out_of_range& e) {
92661       {
92662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92663       };
92664     } catch (std::exception& e) {
92665       {
92666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92667       };
92668     } catch (...) {
92669       {
92670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92671       };
92672     }
92673   }
92674 }
92675
92676
92677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92678   unsigned int jresult ;
92679   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92680   Dali::Toolkit::Slider arg2 ;
92681   float arg3 ;
92682   Dali::Toolkit::Slider *argp2 ;
92683   bool result;
92684
92685   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92686   argp2 = (Dali::Toolkit::Slider *)jarg2;
92687   if (!argp2) {
92688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92689     return 0;
92690   }
92691   arg2 = *argp2;
92692   arg3 = (float)jarg3;
92693   {
92694     try {
92695       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92696     } catch (std::out_of_range& e) {
92697       {
92698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92699       };
92700     } catch (std::exception& e) {
92701       {
92702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92703       };
92704     } catch (...) {
92705       {
92706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92707       };
92708     }
92709   }
92710   jresult = result;
92711   return jresult;
92712 }
92713
92714
92715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92716   void * jresult ;
92717   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92718
92719   {
92720     try {
92721       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92722     } catch (std::out_of_range& e) {
92723       {
92724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92725       };
92726     } catch (std::exception& e) {
92727       {
92728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92729       };
92730     } catch (...) {
92731       {
92732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92733       };
92734     }
92735   }
92736   jresult = (void *)result;
92737   return jresult;
92738 }
92739
92740
92741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92742   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92743
92744   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92745   {
92746     try {
92747       delete arg1;
92748     } catch (std::out_of_range& e) {
92749       {
92750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92751       };
92752     } catch (std::exception& e) {
92753       {
92754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92755       };
92756     } catch (...) {
92757       {
92758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92759       };
92760     }
92761   }
92762 }
92763
92764
92765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92766   unsigned int jresult ;
92767   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92768   bool result;
92769
92770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92771   {
92772     try {
92773       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92774     } catch (std::out_of_range& e) {
92775       {
92776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92777       };
92778     } catch (std::exception& e) {
92779       {
92780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92781       };
92782     } catch (...) {
92783       {
92784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92785       };
92786     }
92787   }
92788   jresult = result;
92789   return jresult;
92790 }
92791
92792
92793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92794   unsigned long jresult ;
92795   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92796   std::size_t result;
92797
92798   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92799   {
92800     try {
92801       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
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 = (unsigned long)result;
92817   return jresult;
92818 }
92819
92820
92821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92822   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92823   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92824
92825   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92826   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92827   {
92828     try {
92829       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92830     } catch (std::out_of_range& e) {
92831       {
92832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92833       };
92834     } catch (std::exception& e) {
92835       {
92836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92837       };
92838     } catch (...) {
92839       {
92840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92841       };
92842     }
92843   }
92844 }
92845
92846
92847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92848   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92849   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92850
92851   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92852   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92853   {
92854     try {
92855       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92856     } catch (std::out_of_range& e) {
92857       {
92858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92859       };
92860     } catch (std::exception& e) {
92861       {
92862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92863       };
92864     } catch (...) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92867       };
92868     }
92869   }
92870 }
92871
92872
92873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92874   unsigned int jresult ;
92875   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92876   Dali::Toolkit::Slider arg2 ;
92877   int arg3 ;
92878   Dali::Toolkit::Slider *argp2 ;
92879   bool result;
92880
92881   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92882   argp2 = (Dali::Toolkit::Slider *)jarg2;
92883   if (!argp2) {
92884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92885     return 0;
92886   }
92887   arg2 = *argp2;
92888   arg3 = (int)jarg3;
92889   {
92890     try {
92891       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92892     } catch (std::out_of_range& e) {
92893       {
92894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92895       };
92896     } catch (std::exception& e) {
92897       {
92898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92899       };
92900     } catch (...) {
92901       {
92902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92903       };
92904     }
92905   }
92906   jresult = result;
92907   return jresult;
92908 }
92909
92910
92911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92912   void * jresult ;
92913   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92914
92915   {
92916     try {
92917       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92918     } catch (std::out_of_range& e) {
92919       {
92920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92921       };
92922     } catch (std::exception& e) {
92923       {
92924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92925       };
92926     } catch (...) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92929       };
92930     }
92931   }
92932   jresult = (void *)result;
92933   return jresult;
92934 }
92935
92936
92937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92938   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92939
92940   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92941   {
92942     try {
92943       delete arg1;
92944     } catch (std::out_of_range& e) {
92945       {
92946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92947       };
92948     } catch (std::exception& e) {
92949       {
92950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92951       };
92952     } catch (...) {
92953       {
92954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92955       };
92956     }
92957   }
92958 }
92959
92960
92961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92962   void * jresult ;
92963   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92964
92965   {
92966     try {
92967       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92968     } catch (std::out_of_range& e) {
92969       {
92970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92971       };
92972     } catch (std::exception& e) {
92973       {
92974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92975       };
92976     } catch (...) {
92977       {
92978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92979       };
92980     }
92981   }
92982   jresult = (void *)result;
92983   return jresult;
92984 }
92985
92986
92987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92988   void * jresult ;
92989   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92991
92992   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92993   {
92994     try {
92995       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92996     } catch (std::out_of_range& e) {
92997       {
92998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92999       };
93000     } catch (std::exception& e) {
93001       {
93002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93003       };
93004     } catch (...) {
93005       {
93006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93007       };
93008     }
93009   }
93010   jresult = (void *)result;
93011   return jresult;
93012 }
93013
93014
93015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93016   void * jresult ;
93017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93018   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93019
93020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93021   if (!arg1) {
93022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93023     return 0;
93024   }
93025   {
93026     try {
93027       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93028     } catch (std::out_of_range& e) {
93029       {
93030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93031       };
93032     } catch (std::exception& e) {
93033       {
93034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93035       };
93036     } catch (...) {
93037       {
93038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93039       };
93040     }
93041   }
93042   jresult = (void *)result;
93043   return jresult;
93044 }
93045
93046
93047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93049
93050   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93051   {
93052     try {
93053       delete arg1;
93054     } catch (std::out_of_range& e) {
93055       {
93056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93057       };
93058     } catch (std::exception& e) {
93059       {
93060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93061       };
93062     } catch (...) {
93063       {
93064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93065       };
93066     }
93067   }
93068 }
93069
93070
93071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93072   void * jresult ;
93073   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93074   Dali::Toolkit::Ruler *result = 0 ;
93075
93076   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93077   {
93078     try {
93079       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93087       };
93088     } catch (...) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93091       };
93092     }
93093   }
93094   jresult = (void *)result;
93095   return jresult;
93096 }
93097
93098
93099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93100   void * jresult ;
93101   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93102   Dali::Toolkit::Ruler *result = 0 ;
93103
93104   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93105   {
93106     try {
93107       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93108     } catch (std::out_of_range& e) {
93109       {
93110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93111       };
93112     } catch (std::exception& e) {
93113       {
93114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93115       };
93116     } catch (...) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93119       };
93120     }
93121   }
93122   jresult = (void *)result;
93123   return jresult;
93124 }
93125
93126
93127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93128   void * jresult ;
93129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93130   Dali::Toolkit::Ruler *result = 0 ;
93131
93132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93133   {
93134     try {
93135       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93136     } catch (std::out_of_range& e) {
93137       {
93138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93139       };
93140     } catch (std::exception& e) {
93141       {
93142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93143       };
93144     } catch (...) {
93145       {
93146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93147       };
93148     }
93149   }
93150   jresult = (void *)result;
93151   return jresult;
93152 }
93153
93154
93155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93156   void * jresult ;
93157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93158   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93159   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93160
93161   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93162   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93163   if (!arg2) {
93164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93165     return 0;
93166   }
93167   {
93168     try {
93169       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93170     } catch (std::out_of_range& e) {
93171       {
93172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93173       };
93174     } catch (std::exception& e) {
93175       {
93176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93177       };
93178     } catch (...) {
93179       {
93180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93181       };
93182     }
93183   }
93184   jresult = (void *)result;
93185   return jresult;
93186 }
93187
93188
93189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93190   void * jresult ;
93191   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93192   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93193   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93194
93195   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93196   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93197   {
93198     try {
93199       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93200     } catch (std::out_of_range& e) {
93201       {
93202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93203       };
93204     } catch (std::exception& e) {
93205       {
93206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93207       };
93208     } catch (...) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93211       };
93212     }
93213   }
93214   jresult = (void *)result;
93215   return jresult;
93216 }
93217
93218
93219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93220   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93221
93222   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93223   {
93224     try {
93225       (arg1)->Reset();
93226     } catch (std::out_of_range& e) {
93227       {
93228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93229       };
93230     } catch (std::exception& e) {
93231       {
93232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93233       };
93234     } catch (...) {
93235       {
93236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93237       };
93238     }
93239   }
93240 }
93241
93242
93243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93245   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93246
93247   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93248   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93249   {
93250     try {
93251       (arg1)->Reset(arg2);
93252     } catch (std::out_of_range& e) {
93253       {
93254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93255       };
93256     } catch (std::exception& e) {
93257       {
93258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93259       };
93260     } catch (...) {
93261       {
93262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93263       };
93264     }
93265   }
93266 }
93267
93268
93269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93270   void * jresult ;
93271   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93272   Dali::Toolkit::Ruler *result = 0 ;
93273
93274   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93275   {
93276     try {
93277       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93278     } catch (std::out_of_range& e) {
93279       {
93280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93281       };
93282     } catch (std::exception& e) {
93283       {
93284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93285       };
93286     } catch (...) {
93287       {
93288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93289       };
93290     }
93291   }
93292   jresult = (void *)result;
93293   return jresult;
93294 }
93295
93296
93297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93298   float jresult ;
93299   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93300   float arg2 ;
93301   float arg3 ;
93302   float result;
93303
93304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93305   arg2 = (float)jarg2;
93306   arg3 = (float)jarg3;
93307   {
93308     try {
93309       result = (float)(*arg1)->Snap(arg2,arg3);
93310     } catch (std::out_of_range& e) {
93311       {
93312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93313       };
93314     } catch (std::exception& e) {
93315       {
93316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93317       };
93318     } catch (...) {
93319       {
93320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93321       };
93322     }
93323   }
93324   jresult = result;
93325   return jresult;
93326 }
93327
93328
93329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93330   float jresult ;
93331   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93332   float arg2 ;
93333   float result;
93334
93335   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93336   arg2 = (float)jarg2;
93337   {
93338     try {
93339       result = (float)(*arg1)->Snap(arg2);
93340     } catch (std::out_of_range& e) {
93341       {
93342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93343       };
93344     } catch (std::exception& e) {
93345       {
93346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93347       };
93348     } catch (...) {
93349       {
93350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93351       };
93352     }
93353   }
93354   jresult = result;
93355   return jresult;
93356 }
93357
93358
93359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93360   float jresult ;
93361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93362   unsigned int arg2 ;
93363   unsigned int *arg3 = 0 ;
93364   bool arg4 ;
93365   float result;
93366
93367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93368   arg2 = (unsigned int)jarg2;
93369   arg3 = (unsigned int *)jarg3;
93370   arg4 = jarg4 ? true : false;
93371   {
93372     try {
93373       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
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 unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93394   unsigned int jresult ;
93395   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93396   float arg2 ;
93397   bool arg3 ;
93398   unsigned int result;
93399
93400   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93401   arg2 = (float)jarg2;
93402   arg3 = jarg3 ? true : false;
93403   {
93404     try {
93405       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93406     } catch (std::out_of_range& e) {
93407       {
93408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93409       };
93410     } catch (std::exception& e) {
93411       {
93412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93413       };
93414     } catch (...) {
93415       {
93416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93417       };
93418     }
93419   }
93420   jresult = result;
93421   return jresult;
93422 }
93423
93424
93425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93426   unsigned int jresult ;
93427   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93428   unsigned int result;
93429
93430   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93431   {
93432     try {
93433       result = (unsigned int)(*arg1)->GetTotalPages();
93434     } catch (std::out_of_range& e) {
93435       {
93436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93437       };
93438     } catch (std::exception& e) {
93439       {
93440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93441       };
93442     } catch (...) {
93443       {
93444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93445       };
93446     }
93447   }
93448   jresult = result;
93449   return jresult;
93450 }
93451
93452
93453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93454   int jresult ;
93455   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93456   Dali::Toolkit::Ruler::RulerType result;
93457
93458   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93459   {
93460     try {
93461       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93462     } catch (std::out_of_range& e) {
93463       {
93464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93465       };
93466     } catch (std::exception& e) {
93467       {
93468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93469       };
93470     } catch (...) {
93471       {
93472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93473       };
93474     }
93475   }
93476   jresult = (int)result;
93477   return jresult;
93478 }
93479
93480
93481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93482   unsigned int jresult ;
93483   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93484   bool result;
93485
93486   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93487   {
93488     try {
93489       result = (bool)(*arg1)->IsEnabled();
93490     } catch (std::out_of_range& e) {
93491       {
93492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93493       };
93494     } catch (std::exception& e) {
93495       {
93496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93497       };
93498     } catch (...) {
93499       {
93500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93501       };
93502     }
93503   }
93504   jresult = result;
93505   return jresult;
93506 }
93507
93508
93509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93511
93512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93513   {
93514     try {
93515       (*arg1)->Enable();
93516     } catch (std::out_of_range& e) {
93517       {
93518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93519       };
93520     } catch (std::exception& e) {
93521       {
93522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93523       };
93524     } catch (...) {
93525       {
93526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93527       };
93528     }
93529   }
93530 }
93531
93532
93533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93535
93536   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93537   {
93538     try {
93539       (*arg1)->Disable();
93540     } catch (std::out_of_range& e) {
93541       {
93542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93543       };
93544     } catch (std::exception& e) {
93545       {
93546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93551       };
93552     }
93553   }
93554 }
93555
93556
93557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93559   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93560   Dali::Toolkit::RulerDomain *argp2 ;
93561
93562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93563   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93564   if (!argp2) {
93565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93566     return ;
93567   }
93568   arg2 = *argp2;
93569   {
93570     try {
93571       (*arg1)->SetDomain(arg2);
93572     } catch (std::out_of_range& e) {
93573       {
93574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93575       };
93576     } catch (std::exception& e) {
93577       {
93578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93579       };
93580     } catch (...) {
93581       {
93582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93583       };
93584     }
93585   }
93586 }
93587
93588
93589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93590   void * jresult ;
93591   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93592   Dali::Toolkit::RulerDomain *result = 0 ;
93593
93594   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93595   {
93596     try {
93597       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93598     } catch (std::out_of_range& e) {
93599       {
93600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93601       };
93602     } catch (std::exception& e) {
93603       {
93604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93605       };
93606     } catch (...) {
93607       {
93608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93609       };
93610     }
93611   }
93612   jresult = (void *)result;
93613   return jresult;
93614 }
93615
93616
93617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93619
93620   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93621   {
93622     try {
93623       (*arg1)->DisableDomain();
93624     } catch (std::out_of_range& e) {
93625       {
93626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93627       };
93628     } catch (std::exception& e) {
93629       {
93630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93631       };
93632     } catch (...) {
93633       {
93634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93635       };
93636     }
93637   }
93638 }
93639
93640
93641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93642   float jresult ;
93643   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93644   float arg2 ;
93645   float arg3 ;
93646   float arg4 ;
93647   float result;
93648
93649   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93650   arg2 = (float)jarg2;
93651   arg3 = (float)jarg3;
93652   arg4 = (float)jarg4;
93653   {
93654     try {
93655       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93656     } catch (std::out_of_range& e) {
93657       {
93658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93659       };
93660     } catch (std::exception& e) {
93661       {
93662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93663       };
93664     } catch (...) {
93665       {
93666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93667       };
93668     }
93669   }
93670   jresult = result;
93671   return jresult;
93672 }
93673
93674
93675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93676   float jresult ;
93677   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93678   float arg2 ;
93679   float arg3 ;
93680   float result;
93681
93682   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93683   arg2 = (float)jarg2;
93684   arg3 = (float)jarg3;
93685   {
93686     try {
93687       result = (float)(*arg1)->Clamp(arg2,arg3);
93688     } catch (std::out_of_range& e) {
93689       {
93690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93691       };
93692     } catch (std::exception& e) {
93693       {
93694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93695       };
93696     } catch (...) {
93697       {
93698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93699       };
93700     }
93701   }
93702   jresult = result;
93703   return jresult;
93704 }
93705
93706
93707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93708   float jresult ;
93709   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93710   float arg2 ;
93711   float result;
93712
93713   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93714   arg2 = (float)jarg2;
93715   {
93716     try {
93717       result = (float)(*arg1)->Clamp(arg2);
93718     } catch (std::out_of_range& e) {
93719       {
93720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93721       };
93722     } catch (std::exception& e) {
93723       {
93724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93725       };
93726     } catch (...) {
93727       {
93728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93729       };
93730     }
93731   }
93732   jresult = result;
93733   return jresult;
93734 }
93735
93736
93737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93738   float jresult ;
93739   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93740   float arg2 ;
93741   float arg3 ;
93742   float arg4 ;
93743   Dali::Toolkit::ClampState *arg5 = 0 ;
93744   float result;
93745
93746   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93747   arg2 = (float)jarg2;
93748   arg3 = (float)jarg3;
93749   arg4 = (float)jarg4;
93750   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93751   if (!arg5) {
93752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93753     return 0;
93754   }
93755   {
93756     try {
93757       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93758     } catch (std::out_of_range& e) {
93759       {
93760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93761       };
93762     } catch (std::exception& e) {
93763       {
93764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93765       };
93766     } catch (...) {
93767       {
93768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93769       };
93770     }
93771   }
93772   jresult = result;
93773   return jresult;
93774 }
93775
93776
93777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93778   float jresult ;
93779   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93780   float arg2 ;
93781   float arg3 ;
93782   float arg4 ;
93783   float arg5 ;
93784   float result;
93785
93786   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93787   arg2 = (float)jarg2;
93788   arg3 = (float)jarg3;
93789   arg4 = (float)jarg4;
93790   arg5 = (float)jarg5;
93791   {
93792     try {
93793       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93794     } catch (std::out_of_range& e) {
93795       {
93796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93797       };
93798     } catch (std::exception& e) {
93799       {
93800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93801       };
93802     } catch (...) {
93803       {
93804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93805       };
93806     }
93807   }
93808   jresult = result;
93809   return jresult;
93810 }
93811
93812
93813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93814   float jresult ;
93815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93816   float arg2 ;
93817   float arg3 ;
93818   float arg4 ;
93819   float result;
93820
93821   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93822   arg2 = (float)jarg2;
93823   arg3 = (float)jarg3;
93824   arg4 = (float)jarg4;
93825   {
93826     try {
93827       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93828     } catch (std::out_of_range& e) {
93829       {
93830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93831       };
93832     } catch (std::exception& e) {
93833       {
93834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93835       };
93836     } catch (...) {
93837       {
93838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93839       };
93840     }
93841   }
93842   jresult = result;
93843   return jresult;
93844 }
93845
93846
93847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93848   float jresult ;
93849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93850   float arg2 ;
93851   float arg3 ;
93852   float result;
93853
93854   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93855   arg2 = (float)jarg2;
93856   arg3 = (float)jarg3;
93857   {
93858     try {
93859       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93860     } catch (std::out_of_range& e) {
93861       {
93862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93863       };
93864     } catch (std::exception& e) {
93865       {
93866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93867       };
93868     } catch (...) {
93869       {
93870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93871       };
93872     }
93873   }
93874   jresult = result;
93875   return jresult;
93876 }
93877
93878
93879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93880   float jresult ;
93881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93882   float arg2 ;
93883   float result;
93884
93885   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93886   arg2 = (float)jarg2;
93887   {
93888     try {
93889       result = (float)(*arg1)->SnapAndClamp(arg2);
93890     } catch (std::out_of_range& e) {
93891       {
93892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93893       };
93894     } catch (std::exception& e) {
93895       {
93896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93897       };
93898     } catch (...) {
93899       {
93900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93901       };
93902     }
93903   }
93904   jresult = result;
93905   return jresult;
93906 }
93907
93908
93909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93910   float jresult ;
93911   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93912   float arg2 ;
93913   float arg3 ;
93914   float arg4 ;
93915   float arg5 ;
93916   Dali::Toolkit::ClampState *arg6 = 0 ;
93917   float result;
93918
93919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93920   arg2 = (float)jarg2;
93921   arg3 = (float)jarg3;
93922   arg4 = (float)jarg4;
93923   arg5 = (float)jarg5;
93924   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93925   if (!arg6) {
93926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93927     return 0;
93928   }
93929   {
93930     try {
93931       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93932     } catch (std::out_of_range& e) {
93933       {
93934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93935       };
93936     } catch (std::exception& e) {
93937       {
93938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93939       };
93940     } catch (...) {
93941       {
93942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93943       };
93944     }
93945   }
93946   jresult = result;
93947   return jresult;
93948 }
93949
93950
93951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93953
93954   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93955   {
93956     try {
93957       (*arg1)->Reference();
93958     } catch (std::out_of_range& e) {
93959       {
93960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93961       };
93962     } catch (std::exception& e) {
93963       {
93964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93965       };
93966     } catch (...) {
93967       {
93968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93969       };
93970     }
93971   }
93972 }
93973
93974
93975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93976   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93977
93978   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93979   {
93980     try {
93981       (*arg1)->Unreference();
93982     } catch (std::out_of_range& e) {
93983       {
93984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93985       };
93986     } catch (std::exception& e) {
93987       {
93988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93989       };
93990     } catch (...) {
93991       {
93992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93993       };
93994     }
93995   }
93996 }
93997
93998
93999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
94000   int jresult ;
94001   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94002   int result;
94003
94004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94005   {
94006     try {
94007       result = (int)(*arg1)->ReferenceCount();
94008     } catch (std::out_of_range& e) {
94009       {
94010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94011       };
94012     } catch (std::exception& e) {
94013       {
94014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94015       };
94016     } catch (...) {
94017       {
94018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94019       };
94020     }
94021   }
94022   jresult = result;
94023   return jresult;
94024 }
94025
94026
94027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94028   unsigned int jresult ;
94029   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94030   bool result;
94031
94032   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94033   {
94034     try {
94035       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94036     } catch (std::out_of_range& e) {
94037       {
94038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94039       };
94040     } catch (std::exception& e) {
94041       {
94042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94043       };
94044     } catch (...) {
94045       {
94046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94047       };
94048     }
94049   }
94050   jresult = result;
94051   return jresult;
94052 }
94053
94054
94055 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94056   unsigned long jresult ;
94057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94058   std::size_t result;
94059
94060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94061   {
94062     try {
94063       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94064     } catch (std::out_of_range& e) {
94065       {
94066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94067       };
94068     } catch (std::exception& e) {
94069       {
94070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94071       };
94072     } catch (...) {
94073       {
94074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94075       };
94076     }
94077   }
94078   jresult = (unsigned long)result;
94079   return jresult;
94080 }
94081
94082
94083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
94084   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94085   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94086
94087   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94088   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94089   {
94090     try {
94091       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94092     } catch (std::out_of_range& e) {
94093       {
94094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94095       };
94096     } catch (std::exception& e) {
94097       {
94098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94099       };
94100     } catch (...) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94103       };
94104     }
94105   }
94106 }
94107
94108
94109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
94110   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94111   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94112
94113   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94114   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94115   {
94116     try {
94117       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94118     } catch (std::out_of_range& e) {
94119       {
94120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94121       };
94122     } catch (std::exception& e) {
94123       {
94124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94125       };
94126     } catch (...) {
94127       {
94128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94129       };
94130     }
94131   }
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
94136   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94137   Dali::Toolkit::Control arg2 ;
94138   Dali::Toolkit::Control *argp2 ;
94139
94140   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94141   argp2 = (Dali::Toolkit::Control *)jarg2;
94142   if (!argp2) {
94143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94144     return ;
94145   }
94146   arg2 = *argp2;
94147   {
94148     try {
94149       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94150     } catch (std::out_of_range& e) {
94151       {
94152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94153       };
94154     } catch (std::exception& e) {
94155       {
94156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94157       };
94158     } catch (...) {
94159       {
94160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94161       };
94162     }
94163   }
94164 }
94165
94166
94167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94168   void * jresult ;
94169   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94170
94171   {
94172     try {
94173       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94174     } catch (std::out_of_range& e) {
94175       {
94176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94177       };
94178     } catch (std::exception& e) {
94179       {
94180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94181       };
94182     } catch (...) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94185       };
94186     }
94187   }
94188   jresult = (void *)result;
94189   return jresult;
94190 }
94191
94192
94193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94194   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94195
94196   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94197   {
94198     try {
94199       delete arg1;
94200     } catch (std::out_of_range& e) {
94201       {
94202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94203       };
94204     } catch (std::exception& e) {
94205       {
94206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94207       };
94208     } catch (...) {
94209       {
94210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94211       };
94212     }
94213   }
94214 }
94215
94216 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94217     return (Dali::RefObject *)jarg1;
94218 }
94219
94220 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94221     return (Dali::SignalObserver *)jarg1;
94222 }
94223
94224 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94225     return (Dali::ConnectionTrackerInterface *)jarg1;
94226 }
94227
94228 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94229     return (Dali::BaseHandle *)jarg1;
94230 }
94231
94232 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94233     return (Dali::BaseHandle *)jarg1;
94234 }
94235
94236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94237     return (Dali::BaseHandle *)jarg1;
94238 }
94239
94240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94241     return (Dali::BaseHandle *)jarg1;
94242 }
94243
94244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94245     return (Dali::BaseHandle *)jarg1;
94246 }
94247
94248 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94249     return (Dali::BaseHandle *)jarg1;
94250 }
94251
94252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94253     return (Dali::BaseHandle *)jarg1;
94254 }
94255
94256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94257     return (Dali::BaseHandle *)jarg1;
94258 }
94259
94260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94261     return (Dali::BaseHandle *)jarg1;
94262 }
94263
94264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94265     return (Dali::BaseHandle *)jarg1;
94266 }
94267
94268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94269     return (Dali::BaseHandle *)jarg1;
94270 }
94271
94272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94273     return (Dali::BaseHandle *)jarg1;
94274 }
94275
94276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94277     return (Dali::BaseHandle *)jarg1;
94278 }
94279
94280 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94281     return (Dali::Handle *)jarg1;
94282 }
94283
94284 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94285     return (Dali::Handle *)jarg1;
94286 }
94287
94288 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94289     return (Dali::BaseHandle *)jarg1;
94290 }
94291
94292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94293     return (Dali::BaseHandle *)jarg1;
94294 }
94295
94296 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94297     return (Dali::Handle *)jarg1;
94298 }
94299
94300 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94301     return (Dali::BaseHandle *)jarg1;
94302 }
94303
94304 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94305     return (Dali::Handle *)jarg1;
94306 }
94307
94308 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94309     return (Dali::GestureDetector *)jarg1;
94310 }
94311
94312 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94313     return (Dali::Gesture *)jarg1;
94314 }
94315
94316 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94317     return (Dali::Handle *)jarg1;
94318 }
94319
94320 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94321     return (Dali::Actor *)jarg1;
94322 }
94323
94324 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94325     return (Dali::BaseHandle *)jarg1;
94326 }
94327
94328 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94329     return (Dali::RefObject *)jarg1;
94330 }
94331
94332 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94333     return (Dali::Actor *)jarg1;
94334 }
94335
94336 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94337     return (Dali::GestureDetector *)jarg1;
94338 }
94339
94340 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94341     return (Dali::Gesture *)jarg1;
94342 }
94343
94344 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94345     return (Dali::GestureDetector *)jarg1;
94346 }
94347
94348 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94349     return (Dali::Gesture *)jarg1;
94350 }
94351
94352 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94353     return (Dali::GestureDetector *)jarg1;
94354 }
94355
94356 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94357     return (Dali::Gesture *)jarg1;
94358 }
94359
94360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94361     return (Dali::BaseHandle *)jarg1;
94362 }
94363
94364 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94365     return (Dali::Handle *)jarg1;
94366 }
94367
94368 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94369     return (Dali::BaseHandle *)jarg1;
94370 }
94371
94372 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94373     return (Dali::Handle *)jarg1;
94374 }
94375
94376 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94377     return (Dali::Handle *)jarg1;
94378 }
94379
94380 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94381     return (Dali::Image *)jarg1;
94382 }
94383
94384 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94385     return (Dali::Image *)jarg1;
94386 }
94387
94388 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94389     return (Dali::Image *)jarg1;
94390 }
94391
94392 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94393     return (Dali::RefObject *)jarg1;
94394 }
94395
94396 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94397     return (Dali::Image *)jarg1;
94398 }
94399
94400 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94401     return (Dali::Image *)jarg1;
94402 }
94403
94404 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94405     return (Dali::ResourceImage *)jarg1;
94406 }
94407
94408 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94409     return (Dali::Actor *)jarg1;
94410 }
94411
94412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94413     return (Dali::BaseHandle *)jarg1;
94414 }
94415
94416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94417     return (Dali::BaseHandle *)jarg1;
94418 }
94419
94420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94421     return (Dali::BaseHandle *)jarg1;
94422 }
94423
94424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94425     return (Dali::BaseHandle *)jarg1;
94426 }
94427
94428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94429     return (Dali::BaseHandle *)jarg1;
94430 }
94431
94432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94433     return (Dali::BaseHandle *)jarg1;
94434 }
94435
94436 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94437     return (Dali::CustomActorImpl *)jarg1;
94438 }
94439
94440 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94441     return (Dali::CustomActor *)jarg1;
94442 }
94443
94444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94445     return (Dali::BaseHandle *)jarg1;
94446 }
94447
94448 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94449     return (Dali::Toolkit::Control *)jarg1;
94450 }
94451
94452 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94453     return (Dali::Toolkit::Control *)jarg1;
94454 }
94455
94456 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94457     return (Dali::Toolkit::Button *)jarg1;
94458 }
94459
94460 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94461     return (Dali::Toolkit::Button *)jarg1;
94462 }
94463
94464 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94465     return (Dali::Toolkit::Button *)jarg1;
94466 }
94467
94468 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94469     return (Dali::Toolkit::Control *)jarg1;
94470 }
94471
94472 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94473     return (Dali::Toolkit::Control *)jarg1;
94474 }
94475
94476 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94477     return (Dali::Toolkit::Control *)jarg1;
94478 }
94479
94480 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94481     return (Dali::Toolkit::Control *)jarg1;
94482 }
94483
94484 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94485     return (Dali::Toolkit::Control *)jarg1;
94486 }
94487
94488 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94489     return (Dali::RefObject *)jarg1;
94490 }
94491
94492 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94493     return (Dali::Toolkit::Scrollable *)jarg1;
94494 }
94495
94496 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94497     return (Dali::BaseHandle *)jarg1;
94498 }
94499
94500 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94501     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94502 }
94503
94504 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94505     return (Dali::RefObject *)jarg1;
94506 }
94507
94508 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94509     return (Dali::Toolkit::Ruler *)jarg1;
94510 }
94511
94512 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94513     return (Dali::Toolkit::Ruler *)jarg1;
94514 }
94515
94516 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94517     return (Dali::Toolkit::Scrollable *)jarg1;
94518 }
94519
94520 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94521     return (Dali::Toolkit::Control *)jarg1;
94522 }
94523
94524 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94525     return (Dali::Toolkit::Control *)jarg1;
94526 }
94527
94528 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94529     return (Dali::Toolkit::Control *)jarg1;
94530 }
94531
94532 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94533     return (Dali::Toolkit::Control *)jarg1;
94534 }
94535
94536 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94537     return (Dali::BaseHandle *)jarg1;
94538 }
94539
94540 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94541     return (Dali::BaseHandle *)jarg1;
94542 }
94543
94544 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94545     return (Dali::Toolkit::Control *)jarg1;
94546 }
94547
94548 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94549     return (Dali::Toolkit::Control *)jarg1;
94550 }
94551
94552 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94553     return (Dali::Toolkit::Control *)jarg1;
94554 }
94555
94556 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94557     return (Dali::Toolkit::Control *)jarg1;
94558 }
94559
94560 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94561     return (Dali::Toolkit::Control *)jarg1;
94562 }
94563
94564 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94565     return (Dali::Toolkit::Control *)jarg1;
94566 }
94567
94568 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94569     return (Dali::Toolkit::PageTurnView *)jarg1;
94570 }
94571
94572 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94573     return (Dali::Toolkit::PageTurnView *)jarg1;
94574 }
94575
94576 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94577     return (Dali::Toolkit::Button *)jarg1;
94578 }
94579
94580 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94581     return (Dali::BaseHandle *)jarg1;
94582 }
94583
94584 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94585     return (Dali::BaseHandle *)jarg1;
94586 }
94587
94588 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94589     return (Dali::BaseHandle *)jarg1;
94590 }
94591
94592
94593
94594
94595
94596 //////////////////////////////////////////////////
94597 //from dali-swig autogeneration (from dali_wrap.cpp)
94598
94599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94600   void * jresult ;
94601   Dali::ImfManager::ImfEventData *result = 0 ;
94602
94603   {
94604     try {
94605       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94606     } catch (std::out_of_range& e) {
94607       {
94608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94609       };
94610     } catch (std::exception& e) {
94611       {
94612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94613       };
94614     } catch (...) {
94615       {
94616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94617       };
94618     }
94619   }
94620   jresult = (void *)result;
94621   return jresult;
94622 }
94623
94624
94625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94626   void * jresult ;
94627   Dali::ImfManager::ImfEvent arg1 ;
94628   std::string *arg2 = 0 ;
94629   int arg3 ;
94630   int arg4 ;
94631   Dali::ImfManager::ImfEventData *result = 0 ;
94632
94633   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94634   if (!jarg2) {
94635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94636     return 0;
94637   }
94638   std::string arg2_str(jarg2);
94639   arg2 = &arg2_str;
94640   arg3 = (int)jarg3;
94641   arg4 = (int)jarg4;
94642   {
94643     try {
94644       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94645     } catch (std::out_of_range& e) {
94646       {
94647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94648       };
94649     } catch (std::exception& e) {
94650       {
94651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94652       };
94653     } catch (...) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94656       };
94657     }
94658   }
94659   jresult = (void *)result;
94660
94661   //argout typemap for const std::string&
94662
94663   return jresult;
94664 }
94665
94666
94667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94668   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94669   std::string *arg2 = 0 ;
94670
94671   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94672   if (!jarg2) {
94673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94674     return ;
94675   }
94676   std::string arg2_str(jarg2);
94677   arg2 = &arg2_str;
94678   if (arg1) (arg1)->predictiveString = *arg2;
94679
94680   //argout typemap for const std::string&
94681
94682 }
94683
94684
94685 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94686   char * jresult ;
94687   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94688   std::string *result = 0 ;
94689
94690   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94691   result = (std::string *) & ((arg1)->predictiveString);
94692   jresult = SWIG_csharp_string_callback(result->c_str());
94693   return jresult;
94694 }
94695
94696
94697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94698   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94699   Dali::ImfManager::ImfEvent arg2 ;
94700
94701   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94702   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94703   if (arg1) (arg1)->eventName = arg2;
94704 }
94705
94706
94707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94708   int jresult ;
94709   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94710   Dali::ImfManager::ImfEvent result;
94711
94712   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94713   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94714   jresult = (int)result;
94715   return jresult;
94716 }
94717
94718
94719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94720   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94721   int arg2 ;
94722
94723   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94724   arg2 = (int)jarg2;
94725   if (arg1) (arg1)->cursorOffset = arg2;
94726 }
94727
94728
94729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94730   int jresult ;
94731   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94732   int result;
94733
94734   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94735   result = (int) ((arg1)->cursorOffset);
94736   jresult = result;
94737   return jresult;
94738 }
94739
94740
94741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94742   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94743   int arg2 ;
94744
94745   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94746   arg2 = (int)jarg2;
94747   if (arg1) (arg1)->numberOfChars = arg2;
94748 }
94749
94750
94751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94752   int jresult ;
94753   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94754   int result;
94755
94756   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94757   result = (int) ((arg1)->numberOfChars);
94758   jresult = result;
94759   return jresult;
94760 }
94761
94762
94763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94764   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94765
94766   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94767   {
94768     try {
94769       delete arg1;
94770     } catch (std::out_of_range& e) {
94771       {
94772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94773       };
94774     } catch (std::exception& e) {
94775       {
94776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94777       };
94778     } catch (...) {
94779       {
94780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94781       };
94782     }
94783   }
94784 }
94785
94786
94787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94788   void * jresult ;
94789   Dali::ImfManager::ImfCallbackData *result = 0 ;
94790
94791   {
94792     try {
94793       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94794     } catch (std::out_of_range& e) {
94795       {
94796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94797       };
94798     } catch (std::exception& e) {
94799       {
94800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94801       };
94802     } catch (...) {
94803       {
94804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94805       };
94806     }
94807   }
94808   jresult = (void *)result;
94809   return jresult;
94810 }
94811
94812
94813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94814   void * jresult ;
94815   bool arg1 ;
94816   int arg2 ;
94817   std::string *arg3 = 0 ;
94818   bool arg4 ;
94819   Dali::ImfManager::ImfCallbackData *result = 0 ;
94820
94821   arg1 = jarg1 ? true : false;
94822   arg2 = (int)jarg2;
94823   if (!jarg3) {
94824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94825     return 0;
94826   }
94827   std::string arg3_str(jarg3);
94828   arg3 = &arg3_str;
94829   arg4 = jarg4 ? true : false;
94830   {
94831     try {
94832       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94833     } catch (std::out_of_range& e) {
94834       {
94835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94836       };
94837     } catch (std::exception& e) {
94838       {
94839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94840       };
94841     } catch (...) {
94842       {
94843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94844       };
94845     }
94846   }
94847   jresult = (void *)result;
94848
94849   //argout typemap for const std::string&
94850
94851   return jresult;
94852 }
94853
94854
94855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94856   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94857   std::string *arg2 = 0 ;
94858
94859   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94860   if (!jarg2) {
94861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94862     return ;
94863   }
94864   std::string arg2_str(jarg2);
94865   arg2 = &arg2_str;
94866   if (arg1) (arg1)->currentText = *arg2;
94867
94868   //argout typemap for const std::string&
94869
94870 }
94871
94872
94873 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94874   char * jresult ;
94875   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94876   std::string *result = 0 ;
94877
94878   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94879   result = (std::string *) & ((arg1)->currentText);
94880   jresult = SWIG_csharp_string_callback(result->c_str());
94881   return jresult;
94882 }
94883
94884
94885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94886   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94887   int arg2 ;
94888
94889   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94890   arg2 = (int)jarg2;
94891   if (arg1) (arg1)->cursorPosition = arg2;
94892 }
94893
94894
94895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94896   int jresult ;
94897   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94898   int result;
94899
94900   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94901   result = (int) ((arg1)->cursorPosition);
94902   jresult = result;
94903   return jresult;
94904 }
94905
94906
94907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94908   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94909   bool arg2 ;
94910
94911   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94912   arg2 = jarg2 ? true : false;
94913   if (arg1) (arg1)->update = arg2;
94914 }
94915
94916
94917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94918   unsigned int jresult ;
94919   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94920   bool result;
94921
94922   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94923   result = (bool) ((arg1)->update);
94924   jresult = result;
94925   return jresult;
94926 }
94927
94928
94929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94930   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94931   bool arg2 ;
94932
94933   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94934   arg2 = jarg2 ? true : false;
94935   if (arg1) (arg1)->preeditResetRequired = arg2;
94936 }
94937
94938
94939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94940   unsigned int jresult ;
94941   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94942   bool result;
94943
94944   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94945   result = (bool) ((arg1)->preeditResetRequired);
94946   jresult = result;
94947   return jresult;
94948 }
94949
94950
94951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94952   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94953
94954   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94955   {
94956     try {
94957       delete arg1;
94958     } catch (std::out_of_range& e) {
94959       {
94960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94961       };
94962     } catch (std::exception& e) {
94963       {
94964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94965       };
94966     } catch (...) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94969       };
94970     }
94971   }
94972 }
94973
94974
94975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94976   void * jresult ;
94977   Dali::ImfManager result;
94978
94979   {
94980     try {
94981       result = Dali::ImfManager::Get();
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94989       };
94990     } catch (...) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94993       };
94994     }
94995   }
94996   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94997   return jresult;
94998 }
94999
95000
95001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
95002   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95003
95004   arg1 = (Dali::ImfManager *)jarg1;
95005   {
95006     try {
95007       (arg1)->Activate();
95008     } catch (std::out_of_range& e) {
95009       {
95010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95011       };
95012     } catch (std::exception& e) {
95013       {
95014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95015       };
95016     } catch (...) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95019       };
95020     }
95021   }
95022 }
95023
95024
95025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
95026   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95027
95028   arg1 = (Dali::ImfManager *)jarg1;
95029   {
95030     try {
95031       (arg1)->Deactivate();
95032     } catch (std::out_of_range& e) {
95033       {
95034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95035       };
95036     } catch (std::exception& e) {
95037       {
95038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95039       };
95040     } catch (...) {
95041       {
95042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95043       };
95044     }
95045   }
95046 }
95047
95048
95049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
95050   unsigned int jresult ;
95051   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95052   bool result;
95053
95054   arg1 = (Dali::ImfManager *)jarg1;
95055   {
95056     try {
95057       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
95058     } catch (std::out_of_range& e) {
95059       {
95060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95061       };
95062     } catch (std::exception& e) {
95063       {
95064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95065       };
95066     } catch (...) {
95067       {
95068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95069       };
95070     }
95071   }
95072   jresult = result;
95073   return jresult;
95074 }
95075
95076
95077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
95078   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95079   bool arg2 ;
95080
95081   arg1 = (Dali::ImfManager *)jarg1;
95082   arg2 = jarg2 ? true : false;
95083   {
95084     try {
95085       (arg1)->SetRestoreAfterFocusLost(arg2);
95086     } catch (std::out_of_range& e) {
95087       {
95088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95089       };
95090     } catch (std::exception& e) {
95091       {
95092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95093       };
95094     } catch (...) {
95095       {
95096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95097       };
95098     }
95099   }
95100 }
95101
95102
95103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
95104   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95105
95106   arg1 = (Dali::ImfManager *)jarg1;
95107   {
95108     try {
95109       (arg1)->Reset();
95110     } catch (std::out_of_range& e) {
95111       {
95112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95113       };
95114     } catch (std::exception& e) {
95115       {
95116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95117       };
95118     } catch (...) {
95119       {
95120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95121       };
95122     }
95123   }
95124 }
95125
95126
95127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
95128   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95129
95130   arg1 = (Dali::ImfManager *)jarg1;
95131   {
95132     try {
95133       (arg1)->NotifyCursorPosition();
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95141       };
95142     } catch (...) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95145       };
95146     }
95147   }
95148 }
95149
95150
95151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95152   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95153   unsigned int arg2 ;
95154
95155   arg1 = (Dali::ImfManager *)jarg1;
95156   arg2 = (unsigned int)jarg2;
95157   {
95158     try {
95159       (arg1)->SetCursorPosition(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 unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95178   unsigned int jresult ;
95179   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95180   unsigned int result;
95181
95182   arg1 = (Dali::ImfManager *)jarg1;
95183   {
95184     try {
95185       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
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 = result;
95201   return jresult;
95202 }
95203
95204
95205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95206   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95207   std::string *arg2 = 0 ;
95208
95209   arg1 = (Dali::ImfManager *)jarg1;
95210   if (!jarg2) {
95211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95212     return ;
95213   }
95214   std::string arg2_str(jarg2);
95215   arg2 = &arg2_str;
95216   {
95217     try {
95218       (arg1)->SetSurroundingText((std::string const &)*arg2);
95219     } catch (std::out_of_range& e) {
95220       {
95221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95222       };
95223     } catch (std::exception& e) {
95224       {
95225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95226       };
95227     } catch (...) {
95228       {
95229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95230       };
95231     }
95232   }
95233
95234   //argout typemap for const std::string&
95235
95236 }
95237
95238
95239 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95240   char * jresult ;
95241   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95242   std::string *result = 0 ;
95243
95244   arg1 = (Dali::ImfManager *)jarg1;
95245   {
95246     try {
95247       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95248     } catch (std::out_of_range& e) {
95249       {
95250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95251       };
95252     } catch (std::exception& e) {
95253       {
95254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95255       };
95256     } catch (...) {
95257       {
95258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95259       };
95260     }
95261   }
95262   jresult = SWIG_csharp_string_callback(result->c_str());
95263   return jresult;
95264 }
95265
95266
95267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95268   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95269   bool arg2 ;
95270
95271   arg1 = (Dali::ImfManager *)jarg1;
95272   arg2 = jarg2 ? true : false;
95273   {
95274     try {
95275       (arg1)->NotifyTextInputMultiLine(arg2);
95276     } catch (std::out_of_range& e) {
95277       {
95278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (std::exception& e) {
95281       {
95282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95283       };
95284     } catch (...) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95287       };
95288     }
95289   }
95290 }
95291
95292
95293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95294   int jresult ;
95295   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95296   Dali::ImfManager::TextDirection result;
95297
95298   arg1 = (Dali::ImfManager *)jarg1;
95299   {
95300     try {
95301       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95302     } catch (std::out_of_range& e) {
95303       {
95304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95305       };
95306     } catch (std::exception& e) {
95307       {
95308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95309       };
95310     } catch (...) {
95311       {
95312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95313       };
95314     }
95315   }
95316   jresult = (int)result;
95317   return jresult;
95318 }
95319
95320
95321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95322   void * jresult ;
95323   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95324   Dali::Rect< int > result;
95325
95326   arg1 = (Dali::ImfManager *)jarg1;
95327   {
95328     try {
95329       result = (arg1)->GetInputMethodArea();
95330     } catch (std::out_of_range& e) {
95331       {
95332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95333       };
95334     } catch (std::exception& e) {
95335       {
95336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95337       };
95338     } catch (...) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95341       };
95342     }
95343   }
95344   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95345   return jresult;
95346 }
95347
95348
95349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95350   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95351   Dali::InputMethodOptions *arg2 = 0 ;
95352
95353   arg1 = (Dali::ImfManager *)jarg1;
95354   arg2 = (Dali::InputMethodOptions *)jarg2;
95355   if (!arg2) {
95356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95357     return ;
95358   }
95359   {
95360     try {
95361       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95362     } catch (std::out_of_range& e) {
95363       {
95364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95365       };
95366     } catch (std::exception& e) {
95367       {
95368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95369       };
95370     } catch (...) {
95371       {
95372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95373       };
95374     }
95375   }
95376 }
95377
95378
95379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95380   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95381   std::string *arg2 = 0 ;
95382
95383   arg1 = (Dali::ImfManager *)jarg1;
95384   if (!jarg2) {
95385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95386     return ;
95387   }
95388   std::string arg2_str(jarg2);
95389   arg2 = &arg2_str;
95390   {
95391     try {
95392       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95393     } catch (std::out_of_range& e) {
95394       {
95395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95396       };
95397     } catch (std::exception& e) {
95398       {
95399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95400       };
95401     } catch (...) {
95402       {
95403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95404       };
95405     }
95406   }
95407
95408   //argout typemap for const std::string&
95409
95410 }
95411
95412
95413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95414   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95415   std::string *arg2 = 0 ;
95416
95417   arg1 = (Dali::ImfManager *)jarg1;
95418   if (!jarg2) {
95419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95420     return ;
95421   }
95422   std::string arg2_str(jarg2);
95423   arg2 = &arg2_str;
95424   {
95425     try {
95426       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95427     } catch (std::out_of_range& e) {
95428       {
95429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95430       };
95431     } catch (std::exception& e) {
95432       {
95433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95434       };
95435     } catch (...) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95438       };
95439     }
95440   }
95441
95442 }
95443
95444
95445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95446   int jresult ;
95447   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95448   Dali::ImfManager::State result;
95449
95450   arg1 = (Dali::ImfManager *)jarg1;
95451   {
95452     try {
95453       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95454     } catch (std::out_of_range& e) {
95455       {
95456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95457       };
95458     } catch (std::exception& e) {
95459       {
95460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95461       };
95462     } catch (...) {
95463       {
95464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95465       };
95466     }
95467   }
95468   jresult = (int)result;
95469   return jresult;
95470 }
95471
95472
95473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95474   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95475   bool arg2 ;
95476
95477   arg1 = (Dali::ImfManager *)jarg1;
95478   arg2 = jarg2 ? true : false;
95479   {
95480     try {
95481       (arg1)->SetReturnKeyState(arg2);
95482     } catch (std::out_of_range& e) {
95483       {
95484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95485       };
95486     } catch (std::exception& e) {
95487       {
95488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95489       };
95490     } catch (...) {
95491       {
95492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95493       };
95494     }
95495   }
95496 }
95497
95498
95499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95500   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95501   bool arg2 ;
95502
95503   arg1 = (Dali::ImfManager *)jarg1;
95504   arg2 = jarg2 ? true : false;
95505   {
95506     try {
95507       (arg1)->AutoEnableInputPanel(arg2);
95508     } catch (std::out_of_range& e) {
95509       {
95510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95511       };
95512     } catch (std::exception& e) {
95513       {
95514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95515       };
95516     } catch (...) {
95517       {
95518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95519       };
95520     }
95521   }
95522 }
95523
95524
95525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95526   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95527
95528   arg1 = (Dali::ImfManager *)jarg1;
95529   {
95530     try {
95531       (arg1)->ShowInputPanel();
95532     } catch (std::out_of_range& e) {
95533       {
95534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95535       };
95536     } catch (std::exception& e) {
95537       {
95538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95539       };
95540     } catch (...) {
95541       {
95542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95543       };
95544     }
95545   }
95546 }
95547
95548
95549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95550   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95551
95552   arg1 = (Dali::ImfManager *)jarg1;
95553   {
95554     try {
95555       (arg1)->HideInputPanel();
95556     } catch (std::out_of_range& e) {
95557       {
95558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95559       };
95560     } catch (std::exception& e) {
95561       {
95562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95563       };
95564     } catch (...) {
95565       {
95566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95567       };
95568     }
95569   }
95570 }
95571
95572
95573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95574   void * jresult ;
95575   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95576   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95577
95578   arg1 = (Dali::ImfManager *)jarg1;
95579   {
95580     try {
95581       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95582     } catch (std::out_of_range& e) {
95583       {
95584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95585       };
95586     } catch (std::exception& e) {
95587       {
95588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95589       };
95590     } catch (...) {
95591       {
95592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95593       };
95594     }
95595   }
95596   jresult = (void *)result;
95597   return jresult;
95598 }
95599
95600
95601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95602   void * jresult ;
95603   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95604   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95605
95606   arg1 = (Dali::ImfManager *)jarg1;
95607   {
95608     try {
95609       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95610     } catch (std::out_of_range& e) {
95611       {
95612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95613       };
95614     } catch (std::exception& e) {
95615       {
95616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95617       };
95618     } catch (...) {
95619       {
95620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95621       };
95622     }
95623   }
95624   jresult = (void *)result;
95625   return jresult;
95626 }
95627
95628
95629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95630   void * jresult ;
95631   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95632   Dali::ImfManager::StatusSignalType *result = 0 ;
95633
95634   arg1 = (Dali::ImfManager *)jarg1;
95635   {
95636     try {
95637       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95638     } catch (std::out_of_range& e) {
95639       {
95640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95641       };
95642     } catch (std::exception& e) {
95643       {
95644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95645       };
95646     } catch (...) {
95647       {
95648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95649       };
95650     }
95651   }
95652   jresult = (void *)result;
95653   return jresult;
95654 }
95655
95656
95657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95658   void * jresult ;
95659   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95660   Dali::ImfManager::VoidSignalType *result = 0 ;
95661
95662   arg1 = (Dali::ImfManager *)jarg1;
95663   {
95664     try {
95665       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95666     } catch (std::out_of_range& e) {
95667       {
95668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95669       };
95670     } catch (std::exception& e) {
95671       {
95672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95673       };
95674     } catch (...) {
95675       {
95676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95677       };
95678     }
95679   }
95680   jresult = (void *)result;
95681   return jresult;
95682 }
95683
95684
95685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95686   void * jresult ;
95687   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95688   Dali::ImfManager::VoidSignalType *result = 0 ;
95689
95690   arg1 = (Dali::ImfManager *)jarg1;
95691   {
95692     try {
95693       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95694     } catch (std::out_of_range& e) {
95695       {
95696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95697       };
95698     } catch (std::exception& e) {
95699       {
95700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95701       };
95702     } catch (...) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95705       };
95706     }
95707   }
95708   jresult = (void *)result;
95709   return jresult;
95710 }
95711
95712
95713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95714   void * jresult ;
95715   Dali::ImfManager *result = 0 ;
95716
95717   {
95718     try {
95719       result = (Dali::ImfManager *)new Dali::ImfManager();
95720     } catch (std::out_of_range& e) {
95721       {
95722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95723       };
95724     } catch (std::exception& e) {
95725       {
95726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95727       };
95728     } catch (...) {
95729       {
95730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95731       };
95732     }
95733   }
95734   jresult = (void *)result;
95735   return jresult;
95736 }
95737
95738
95739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95740   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95741
95742   arg1 = (Dali::ImfManager *)jarg1;
95743   {
95744     try {
95745       delete arg1;
95746     } catch (std::out_of_range& e) {
95747       {
95748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95749       };
95750     } catch (std::exception& e) {
95751       {
95752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95753       };
95754     } catch (...) {
95755       {
95756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95757       };
95758     }
95759   }
95760 }
95761
95762
95763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95764   void * jresult ;
95765   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95766   Dali::ImfManager *result = 0 ;
95767
95768   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95769   {
95770     try {
95771       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95772     } catch (std::out_of_range& e) {
95773       {
95774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95775       };
95776     } catch (std::exception& e) {
95777       {
95778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95779       };
95780     } catch (...) {
95781       {
95782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95783       };
95784     }
95785   }
95786   jresult = (void *)result;
95787   return jresult;
95788 }
95789
95790
95791 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95792     return (Dali::BaseHandle *)jarg1;
95793 }
95794
95795
95796 //////////////////////////////////////////////////
95797 //from dali-swig autogeneration (from dali_wrap.cpp)
95798
95799
95800
95801
95802
95803
95804
95805
95806
95807
95808
95809
95810 #ifdef __cplusplus
95811 }
95812 #endif