dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/animation/animation-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/window.h>
 439 #include <dali/public-api/adaptor-framework/style-change.h>
 440 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 441 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 442 #include <dali/devel-api/adaptor-framework/window-devel.h>
 443
 444 #include <dali/devel-api/images/nine-patch-image.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 454 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 458 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 459 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 460 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 461
 462 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 463 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 464 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 465
 466 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 470
 471 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 472
 473 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 474
 475
 476 // add here SWIG version check
 477
 478 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 479 // disable Swig-dependent warnings
 480
 481 // 'identifier1' has C-linkage specified,
 482 // but returns UDT 'identifier2' which is incompatible with C
 483 #pragma warning(disable: 4190)
 484
 485 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 486 #pragma warning(disable: 4800)
 487
 488 // debug info too long etc etc
 489 #pragma warning(disable: 4786)
 490 #endif
 491
 492
 493 #include <stdexcept>
 494
 495
 496 #include <string>
 497
 498
 499 #include <vector>
 500 #include <algorithm>
 501 #include <stdexcept>
 502
 503
 504 #include <map>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <utility>
 510
 511
 512 typedef float floatp;
 513
 514 SWIGINTERN floatp *new_floatp(){
 515   return new float();
 516 }
 517 SWIGINTERN void delete_floatp(floatp *self){
 518   if (self) delete self;
 519 }
 520 SWIGINTERN void floatp_assign(floatp *self,float value){
 521   *self = value;
 522 }
 523 SWIGINTERN float floatp_value(floatp *self){
 524   return *self;
 525 }
 526 SWIGINTERN float *floatp_cast(floatp *self){
 527   return self;
 528 }
 529 SWIGINTERN floatp *floatp_frompointer(float *t){
 530   return (floatp *) t;
 531 }
 532
 533 typedef int intp;
 534
 535 SWIGINTERN intp *new_intp(){
 536   return new int();
 537 }
 538 SWIGINTERN void delete_intp(intp *self){
 539   if (self) delete self;
 540 }
 541 SWIGINTERN void intp_assign(intp *self,int value){
 542   *self = value;
 543 }
 544 SWIGINTERN int intp_value(intp *self){
 545   return *self;
 546 }
 547 SWIGINTERN int *intp_cast(intp *self){
 548   return self;
 549 }
 550 SWIGINTERN intp *intp_frompointer(int *t){
 551   return (intp *) t;
 552 }
 553
 554 typedef double doublep;
 555
 556 SWIGINTERN doublep *new_doublep(){
 557   return new double();
 558 }
 559 SWIGINTERN void delete_doublep(doublep *self){
 560   if (self) delete self;
 561 }
 562 SWIGINTERN void doublep_assign(doublep *self,double value){
 563   *self = value;
 564 }
 565 SWIGINTERN double doublep_value(doublep *self){
 566   return *self;
 567 }
 568 SWIGINTERN double *doublep_cast(doublep *self){
 569   return self;
 570 }
 571 SWIGINTERN doublep *doublep_frompointer(double *t){
 572   return (doublep *) t;
 573 }
 574
 575 typedef unsigned int uintp;
 576
 577 SWIGINTERN uintp *new_uintp(){
 578   return new unsigned int();
 579 }
 580 SWIGINTERN void delete_uintp(uintp *self){
 581   if (self) delete self;
 582 }
 583 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 584   *self = value;
 585 }
 586 SWIGINTERN unsigned int uintp_value(uintp *self){
 587   return *self;
 588 }
 589 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 590   return self;
 591 }
 592 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 593   return (uintp *) t;
 594 }
 595
 596 typedef unsigned short ushortp;
 597
 598 SWIGINTERN ushortp *new_ushortp(){
 599   return new unsigned short();
 600 }
 601 SWIGINTERN void delete_ushortp(ushortp *self){
 602   if (self) delete self;
 603 }
 604 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 605   *self = value;
 606 }
 607 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 608   return *self;
 609 }
 610 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 611   return self;
 612 }
 613 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 614   return (ushortp *) t;
 615 }
 616
 617 unsigned int int_to_uint(int x) {
 618    return (unsigned int) x;
 619 }
 620
 621
 622 using namespace Dali;
 623 using namespace Dali::Toolkit;
 624
 625 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 626
 627      // C++ code. DALi uses Handle <-> Body design pattern.
 628      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 629      // Handles in DALi can be converted into a boolean type
 630      // to check if the handle has a valid body attached to it.
 631      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 632      if( *self )
 633      {
 634        return true;
 635      }
 636      else
 637      {
 638        return false;
 639      }
 640     }
 641 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 642
 643      // C++ code. Check if two handles reference the same implemtion
 644      if( *self == rhs)
 645      {
 646        return true;
 647      }
 648      else
 649      {
 650        return false;
 651      }
 652     }
 653 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 654      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 655    }
 656 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 657      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 658    }
 659 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 660         std::vector< Dali::TouchPoint >* pv = 0;
 661         if (capacity >= 0) {
 662           pv = new std::vector< Dali::TouchPoint >();
 663           pv->reserve(capacity);
 664        } else {
 665           throw std::out_of_range("capacity");
 666        }
 667        return pv;
 668       }
 669 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 670         if (index>=0 && index<(int)self->size())
 671           return (*self)[index];
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 676         if (index>=0 && index<(int)self->size())
 677           return (*self)[index];
 678         else
 679           throw std::out_of_range("index");
 680       }
 681 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 682         if (index>=0 && index<(int)self->size())
 683           (*self)[index] = val;
 684         else
 685           throw std::out_of_range("index");
 686       }
 687 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 688         self->insert(self->end(), values.begin(), values.end());
 689       }
 690 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 691         if (index < 0)
 692           throw std::out_of_range("index");
 693         if (count < 0)
 694           throw std::out_of_range("count");
 695         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 696           throw std::invalid_argument("invalid range");
 697         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 700         if (index>=0 && index<(int)self->size()+1)
 701           self->insert(self->begin()+index, x);
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 706         if (index>=0 && index<(int)self->size()+1)
 707           self->insert(self->begin()+index, values.begin(), values.end());
 708         else
 709           throw std::out_of_range("index");
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 712         if (index>=0 && index<(int)self->size())
 713           self->erase(self->begin() + index);
 714         else
 715           throw std::out_of_range("index");
 716       }
 717 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 718         if (index < 0)
 719           throw std::out_of_range("index");
 720         if (count < 0)
 721           throw std::out_of_range("count");
 722         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 723           throw std::invalid_argument("invalid range");
 724         self->erase(self->begin()+index, self->begin()+index+count);
 725       }
 726 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 727         if (count < 0)
 728           throw std::out_of_range("count");
 729         return new std::vector< Dali::TouchPoint >(count, value);
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 732         std::reverse(self->begin(), self->end());
 733       }
 734 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 735         if (index < 0)
 736           throw std::out_of_range("index");
 737         if (count < 0)
 738           throw std::out_of_range("count");
 739         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 740           throw std::invalid_argument("invalid range");
 741         std::reverse(self->begin()+index, self->begin()+index+count);
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 744         if (index < 0)
 745           throw std::out_of_range("index");
 746         if (index+values.size() > self->size())
 747           throw std::out_of_range("index");
 748         std::copy(values.begin(), values.end(), self->begin()+index);
 749       }
 750 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 751          return self->Empty();
 752       }
 753 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 754         return self->GetConnectionCount();
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Connect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 760           self->Disconnect( func );
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 763           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 764 /*@SWIG@*/ self->Emit( arg );
 765       }
 766 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767          return self->Empty();
 768       }
 769 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 770         return self->GetConnectionCount();
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Connect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 776           self->Disconnect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 779           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 780 /*@SWIG@*/ self->Emit( arg );
 781       }
 782 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 783          return self->Empty();
 784       }
 785 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 786         return self->GetConnectionCount();
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 789           self->Connect( func );
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 792           self->Disconnect( func );
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 795           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 796 /*@SWIG@*/ self->Emit( arg );
 797       }
 798 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799          return self->Empty();
 800       }
 801 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 802         return self->GetConnectionCount();
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Connect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 808           self->Disconnect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 811           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 812 /*@SWIG@*/ self->Emit( arg );
 813       }
 814 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 815          return self->Empty();
 816       }
 817 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 818         return self->GetConnectionCount();
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Connect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 824           self->Disconnect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 827           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 828 /*@SWIG@*/ self->Emit( arg );
 829       }
 830 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 831          return self->Empty();
 832       }
 833 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 834         return self->GetConnectionCount();
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 837         self->Connect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 840         self->Disconnect( func );
 841       }
 842 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 843         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 844 /*@SWIG@*/ self->Emit( arg1, arg2 );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 847          return self->Empty();
 848       }
 849 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 850         return self->GetConnectionCount();
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 853         self->Connect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 856         self->Disconnect( func );
 857       }
 858 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 859         return self->Emit( arg1, arg2 );
 860       }
 861 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 862          return self->Empty();
 863       }
 864 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 865         return self->GetConnectionCount();
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 868         self->Connect( func );
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 871         self->Disconnect( func );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 874         return self->Emit( arg1, arg2 );
 875       }
 876 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 877          return self->Empty();
 878       }
 879 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 880         return self->GetConnectionCount();
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 883         self->Connect( func );
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 886         self->Disconnect( func );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 889         return self->Emit( arg1, arg2 );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 892          return self->Empty();
 893       }
 894 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 895         return self->GetConnectionCount();
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Connect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 901           self->Disconnect( func );
 902       }
 903 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 904           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg );
 906       }
 907 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 908          return self->Empty();
 909       }
 910 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 911         return self->GetConnectionCount();
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 914           self->Connect( func );
 915       }
 916 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 917           self->Disconnect( func );
 918       }
 919 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 920           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 921 /*@SWIG@*/ self->Emit( arg );
 922       }
 923 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 924          return self->Empty();
 925       }
 926 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 927         return self->GetConnectionCount();
 928       }
 929 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 930           self->Connect( func );
 931       }
 932 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 933           self->Disconnect( func );
 934       }
 935 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 936           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 937 /*@SWIG@*/ self->Emit( arg );
 938       }
 939 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 940          return self->Empty();
 941       }
 942 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 943         return self->GetConnectionCount();
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 946           self->Connect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 949           self->Disconnect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 952           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg );
 954       }
 955 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 956          return self->Empty();
 957       }
 958 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 959         return self->GetConnectionCount();
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 962         self->Connect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 965         self->Disconnect( func );
 966       }
 967 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 968         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg1, arg2 );
 970       }
 971 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 972          return self->Empty();
 973       }
 974 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 975         return self->GetConnectionCount();
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 978         self->Connect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 981         self->Disconnect( func );
 982       }
 983 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 984         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg1, arg2 );
 986       }
 987 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 988          return self->Empty();
 989       }
 990 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 991         return self->GetConnectionCount();
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 994         self->Connect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 997         self->Disconnect( func );
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1000         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1001 /*@SWIG@*/ self->Emit( arg1, arg2 );
1002       }
1003 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1004          return self->Empty();
1005       }
1006 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1007         return self->GetConnectionCount();
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1010           self->Connect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1013           self->Disconnect( func );
1014       }
1015 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1016           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1017 /*@SWIG@*/ self->Emit( arg );
1018       }
1019 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1020          return self->Empty();
1021       }
1022 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1023         return self->GetConnectionCount();
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1026           self->Connect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1029           self->Disconnect( func );
1030       }
1031 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1032           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1033 /*@SWIG@*/ self->Emit( arg );
1034       }
1035 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1036          return self->Empty();
1037       }
1038 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1039         return self->GetConnectionCount();
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1042           return self->Connect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1045           self->Disconnect( func );
1046       }
1047 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1048           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1049 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1050       }
1051
1052   // keep argcs and argv so they're always available to DALi
1053   int argC = 1;
1054   char **argV = NULL;
1055
1056 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1057          return self->Empty();
1058       }
1059 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1060         return self->GetConnectionCount();
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1063           self->Connect( func );
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1066           self->Disconnect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1069           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1070 /*@SWIG@*/ self->Emit( arg );
1071       }
1072 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1073          return self->Empty();
1074       }
1075 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1076         return self->GetConnectionCount();
1077       }
1078 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1079         self->Connect( func );
1080       }
1081 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1082         self->Disconnect( func );
1083       }
1084 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1085         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1086 /*@SWIG@*/ self->Emit( arg1, arg2 );
1087       }
1088 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1089          return self->Empty();
1090       }
1091 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1092         return self->GetConnectionCount();
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1095           self->Connect( func );
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Disconnect( func );
1099       }
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1101           return self->Emit();
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1104          return self->Empty();
1105       }
1106 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1107         return self->GetConnectionCount();
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1110           self->Connect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1113           self->Disconnect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1116           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1117 /*@SWIG@*/ self->Emit( arg );
1118       }
1119 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1120         std::vector< unsigned int >* pv = 0;
1121         if (capacity >= 0) {
1122           pv = new std::vector< unsigned int >();
1123           pv->reserve(capacity);
1124        } else {
1125           throw std::out_of_range("capacity");
1126        }
1127        return pv;
1128       }
1129 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           return (*self)[index];
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1142         if (index>=0 && index<(int)self->size())
1143           (*self)[index] = val;
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1148         self->insert(self->end(), values.begin(), values.end());
1149       }
1150 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (count < 0)
1154           throw std::out_of_range("count");
1155         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1156           throw std::invalid_argument("invalid range");
1157         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1160         if (index>=0 && index<(int)self->size()+1)
1161           self->insert(self->begin()+index, x);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, values.begin(), values.end());
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1172         if (index>=0 && index<(int)self->size())
1173           self->erase(self->begin() + index);
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         self->erase(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         return new std::vector< unsigned int >(count, value);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1192         std::reverse(self->begin(), self->end());
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         std::reverse(self->begin()+index, self->begin()+index+count);
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (index+values.size() > self->size())
1207           throw std::out_of_range("index");
1208         std::copy(values.begin(), values.end(), self->begin()+index);
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1211         return std::find(self->begin(), self->end(), value) != self->end();
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1216         if (it != self->end())
1217           index = (int)(it - self->begin());
1218         return index;
1219       }
1220 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1221         int index = -1;
1222         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1223         if (rit != self->rend())
1224           index = (int)(self->rend() - 1 - rit);
1225         return index;
1226       }
1227 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1228         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1229         if (it != self->end()) {
1230           self->erase(it);
1231           return true;
1232         }
1233         return false;
1234       }
1235 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1236         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1237         if (capacity >= 0) {
1238           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1239           pv->reserve(capacity);
1240        } else {
1241           throw std::out_of_range("capacity");
1242        }
1243        return pv;
1244       }
1245 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1246         if (index>=0 && index<(int)self->size())
1247           return (*self)[index];
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1258         if (index>=0 && index<(int)self->size())
1259           (*self)[index] = val;
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1264         self->insert(self->end(), values.begin(), values.end());
1265       }
1266 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (count < 0)
1270           throw std::out_of_range("count");
1271         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1272           throw std::invalid_argument("invalid range");
1273         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1276         if (index>=0 && index<(int)self->size()+1)
1277           self->insert(self->begin()+index, x);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, values.begin(), values.end());
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1288         if (index>=0 && index<(int)self->size())
1289           self->erase(self->begin() + index);
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         self->erase(self->begin()+index, self->begin()+index+count);
1301       }
1302 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1308         std::reverse(self->begin(), self->end());
1309       }
1310 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (count < 0)
1314           throw std::out_of_range("count");
1315         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1316           throw std::invalid_argument("invalid range");
1317         std::reverse(self->begin()+index, self->begin()+index+count);
1318       }
1319 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (index+values.size() > self->size())
1323           throw std::out_of_range("index");
1324         std::copy(values.begin(), values.end(), self->begin()+index);
1325       }
1326 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1327         std::vector< Dali::Actor >* pv = 0;
1328         if (capacity >= 0) {
1329           pv = new std::vector< Dali::Actor >();
1330           pv->reserve(capacity);
1331        } else {
1332           throw std::out_of_range("capacity");
1333        }
1334        return pv;
1335       }
1336 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           return (*self)[index];
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1349         if (index>=0 && index<(int)self->size())
1350           (*self)[index] = val;
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1355         self->insert(self->end(), values.begin(), values.end());
1356       }
1357 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (count < 0)
1361           throw std::out_of_range("count");
1362         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1363           throw std::invalid_argument("invalid range");
1364         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1367         if (index>=0 && index<(int)self->size()+1)
1368           self->insert(self->begin()+index, x);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, values.begin(), values.end());
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1379         if (index>=0 && index<(int)self->size())
1380           self->erase(self->begin() + index);
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         self->erase(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         return new std::vector< Dali::Actor >(count, value);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1399         std::reverse(self->begin(), self->end());
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (count < 0)
1405           throw std::out_of_range("count");
1406         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1407           throw std::invalid_argument("invalid range");
1408         std::reverse(self->begin()+index, self->begin()+index+count);
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (index+values.size() > self->size())
1414           throw std::out_of_range("index");
1415         std::copy(values.begin(), values.end(), self->begin()+index);
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1424           self->Connect( func );
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1427           self->Disconnect( func );
1428       }
1429 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1430           return self->Emit( arg );
1431       }
1432 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1433          return self->Empty();
1434       }
1435 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1436         return self->GetConnectionCount();
1437       }
1438 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1439         self->Connect( func );
1440       }
1441 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1442         self->Disconnect( func );
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1445         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1446 /*@SWIG@*/ self->Emit( arg1, arg2 );
1447       }
1448 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1449          return self->Empty();
1450       }
1451 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452         return self->GetConnectionCount();
1453       }
1454 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1455         self->Connect( func );
1456       }
1457 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1458         self->Disconnect( func );
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1461         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1462 /*@SWIG@*/ self->Emit( arg1, arg2 );
1463       }
1464 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465          return self->Empty();
1466       }
1467 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468         return self->GetConnectionCount();
1469       }
1470 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1471         self->Connect( func );
1472       }
1473 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1474         self->Disconnect( func );
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1477         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1478 /*@SWIG@*/ self->Emit( arg1, arg2 );
1479       }
1480 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1481          return self->Empty();
1482       }
1483 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1484         return self->GetConnectionCount();
1485       }
1486 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1487         self->Connect( func );
1488       }
1489 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1490         self->Disconnect( func );
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1493         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1494 /*@SWIG@*/ self->Emit( arg1, arg2 );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497          return self->Empty();
1498       }
1499 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500         return self->GetConnectionCount();
1501       }
1502 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1503           self->Connect( func );
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1506           self->Disconnect( func );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1509           return self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1518           self->Connect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1534           return self->Connect( func );
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1537           self->Disconnect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1550           self->Connect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1553           self->Disconnect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1556           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1557 /*@SWIG@*/ self->Emit( arg );
1558       }
1559 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1560          return self->Empty();
1561       }
1562 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1563         return self->GetConnectionCount();
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1566           return self->Connect( func );
1567       }
1568 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1569           self->Disconnect( func );
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1572           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1573 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1574       }
1575 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1576          return self->Empty();
1577       }
1578 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1579         return self->GetConnectionCount();
1580       }
1581 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1582           self->Connect( func );
1583       }
1584 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1585           self->Disconnect( func );
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1588           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1589 /*@SWIG@*/ self->Emit( arg );
1590       }
1591 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1592          return self->Empty();
1593       }
1594 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595         return self->GetConnectionCount();
1596       }
1597 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1598           self->Connect( func );
1599       }
1600 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1601           self->Disconnect( func );
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1604           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1605 /*@SWIG@*/ self->Emit( arg );
1606       }
1607 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1608          return self->Empty();
1609       }
1610 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1611         return self->GetConnectionCount();
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1614           self->Connect( func );
1615       }
1616 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1617           self->Disconnect( func );
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1620           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1621 /*@SWIG@*/ self->Emit( arg );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1630           self->Connect( func );
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1640          return self->Empty();
1641       }
1642 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1643         return self->GetConnectionCount();
1644       }
1645 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1646         self->Connect( func );
1647       }
1648 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1649         self->Disconnect( func );
1650       }
1651 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1652         return self->Emit( arg1, arg2 );
1653       }
1654 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1655          return self->Empty();
1656       }
1657 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1658         return self->GetConnectionCount();
1659       }
1660 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1661           self->Connect( func );
1662       }
1663 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1664           self->Disconnect( func );
1665       }
1666 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1667           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1668 /*@SWIG@*/ self->Emit( arg );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1671          return self->Empty();
1672       }
1673 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1674         return self->GetConnectionCount();
1675       }
1676 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1677           self->Connect( func );
1678       }
1679 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1680           self->Disconnect( func );
1681       }
1682 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1683           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1684 /*@SWIG@*/ self->Emit( arg );
1685       }
1686 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1687          return self->Empty();
1688       }
1689 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1690         return self->GetConnectionCount();
1691       }
1692 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1693         self->Connect( func );
1694       }
1695 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1696         self->Disconnect( func );
1697       }
1698 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1699         return self->Emit( arg1, arg2 );
1700       }
1701 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1702          return self->Empty();
1703       }
1704 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1705         return self->GetConnectionCount();
1706       }
1707 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1708         self->Connect( func );
1709       }
1710 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1711         self->Disconnect( func );
1712       }
1713 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1714         return self->Emit( arg1, arg2 );
1715       }
1716
1717
1718 /* ---------------------------------------------------
1719  * C++ director class methods
1720  * --------------------------------------------------- */
1721
1722 #include "dali_wrap.h"
1723
1724 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1725   swig_init_callbacks();
1726 }
1727
1728 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1729
1730 }
1731
1732
1733 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1734   int jdepth  ;
1735
1736   if (!swig_callbackOnStageConnection) {
1737     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1738     return;
1739   } else {
1740     jdepth = depth;
1741     swig_callbackOnStageConnection(jdepth);
1742   }
1743 }
1744
1745 void SwigDirector_ViewImpl::OnStageDisconnection() {
1746   if (!swig_callbackOnStageDisconnection) {
1747     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1748     return;
1749   } else {
1750     swig_callbackOnStageDisconnection();
1751   }
1752 }
1753
1754 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1755   void * jchild = 0 ;
1756
1757   if (!swig_callbackOnChildAdd) {
1758     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1759     return;
1760   } else {
1761     jchild = (Dali::Actor *) &child;
1762     swig_callbackOnChildAdd(jchild);
1763   }
1764 }
1765
1766 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1767   void * jchild = 0 ;
1768
1769   if (!swig_callbackOnChildRemove) {
1770     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1771     return;
1772   } else {
1773     jchild = (Dali::Actor *) &child;
1774     swig_callbackOnChildRemove(jchild);
1775   }
1776 }
1777
1778 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1779   int jindex  ;
1780   void * jpropertyValue  ;
1781
1782   if (!swig_callbackOnPropertySet) {
1783     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1784     return;
1785   } else {
1786     jindex = index;
1787     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1788     swig_callbackOnPropertySet(jindex, jpropertyValue);
1789   }
1790 }
1791
1792 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1793   void * jtargetSize = 0 ;
1794
1795   if (!swig_callbackOnSizeSet) {
1796     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1797     return;
1798   } else {
1799     jtargetSize = (Dali::Vector3 *) &targetSize;
1800     swig_callbackOnSizeSet(jtargetSize);
1801   }
1802 }
1803
1804 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1805   void * janimation = 0 ;
1806   void * jtargetSize = 0 ;
1807
1808   if (!swig_callbackOnSizeAnimation) {
1809     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1810     return;
1811   } else {
1812     janimation = (Dali::Animation *) &animation;
1813     jtargetSize = (Dali::Vector3 *) &targetSize;
1814     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1815   }
1816 }
1817
1818 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1819   bool c_result = SwigValueInit< bool >() ;
1820   unsigned int jresult = 0 ;
1821   void * jarg0 = 0 ;
1822
1823   if (!swig_callbackOnTouchEvent) {
1824     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1825   } else {
1826     jarg0 = (Dali::TouchEvent *) &event;
1827     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1828     c_result = jresult ? true : false;
1829   }
1830   return c_result;
1831 }
1832
1833 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1834   bool c_result = SwigValueInit< bool >() ;
1835   unsigned int jresult = 0 ;
1836   void * jarg0 = 0 ;
1837
1838   if (!swig_callbackOnHoverEvent) {
1839     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1840   } else {
1841     jarg0 = (Dali::HoverEvent *) &event;
1842     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1843     c_result = jresult ? true : false;
1844   }
1845   return c_result;
1846 }
1847
1848 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1849   bool c_result = SwigValueInit< bool >() ;
1850   unsigned int jresult = 0 ;
1851   void * jarg0 = 0 ;
1852
1853   if (!swig_callbackOnKeyEvent) {
1854     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1855   } else {
1856     jarg0 = (Dali::KeyEvent *) &event;
1857     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1858     c_result = jresult ? true : false;
1859   }
1860   return c_result;
1861 }
1862
1863 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1864   bool c_result = SwigValueInit< bool >() ;
1865   unsigned int jresult = 0 ;
1866   void * jarg0 = 0 ;
1867
1868   if (!swig_callbackOnWheelEvent) {
1869     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1870   } else {
1871     jarg0 = (Dali::WheelEvent *) &event;
1872     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1873     c_result = jresult ? true : false;
1874   }
1875   return c_result;
1876 }
1877
1878 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1879   void * jsize = 0 ;
1880   void * jcontainer = 0 ;
1881
1882   if (!swig_callbackOnRelayout) {
1883     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1884     return;
1885   } else {
1886     jsize = (Dali::Vector2 *) &size;
1887     jcontainer = (Dali::RelayoutContainer *) &container;
1888     swig_callbackOnRelayout(jsize, jcontainer);
1889   }
1890 }
1891
1892 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1893   int jpolicy  ;
1894   int jdimension  ;
1895
1896   if (!swig_callbackOnSetResizePolicy) {
1897     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1898     return;
1899   } else {
1900     jpolicy = (int)policy;
1901     jdimension = (int)dimension;
1902     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1903   }
1904 }
1905
1906 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1907   Dali::Vector3 c_result ;
1908   void * jresult = 0 ;
1909
1910   if (!swig_callbackGetNaturalSize) {
1911     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1912   } else {
1913     jresult = (void *) swig_callbackGetNaturalSize();
1914     if (!jresult) {
1915       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1916       return c_result;
1917     }
1918     c_result = *(Dali::Vector3 *)jresult;
1919   }
1920   return c_result;
1921 }
1922
1923 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1924   float c_result = SwigValueInit< float >() ;
1925   float jresult = 0 ;
1926   void * jchild = 0 ;
1927   int jdimension  ;
1928
1929   if (!swig_callbackCalculateChildSize) {
1930     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1931   } else {
1932     jchild = (Dali::Actor *) &child;
1933     jdimension = (int)dimension;
1934     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1935     c_result = (float)jresult;
1936   }
1937   return c_result;
1938 }
1939
1940 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1941   float c_result = SwigValueInit< float >() ;
1942   float jresult = 0 ;
1943   float jwidth  ;
1944
1945   if (!swig_callbackGetHeightForWidth) {
1946     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1947   } else {
1948     jwidth = width;
1949     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1950     c_result = (float)jresult;
1951   }
1952   return c_result;
1953 }
1954
1955 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1956   float c_result = SwigValueInit< float >() ;
1957   float jresult = 0 ;
1958   float jheight  ;
1959
1960   if (!swig_callbackGetWidthForHeight) {
1961     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1962   } else {
1963     jheight = height;
1964     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1965     c_result = (float)jresult;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   int jdimension  ;
1974
1975   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1976     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1977   } else {
1978     jdimension = (int)dimension;
1979     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1986   int jdimension  ;
1987
1988   if (!swig_callbackOnCalculateRelayoutSize) {
1989     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1990     return;
1991   } else {
1992     jdimension = (int)dimension;
1993     swig_callbackOnCalculateRelayoutSize(jdimension);
1994   }
1995 }
1996
1997 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1998   float jsize  ;
1999   int jdimension  ;
2000
2001   if (!swig_callbackOnLayoutNegotiated) {
2002     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2003     return;
2004   } else {
2005     jsize = size;
2006     jdimension = (int)dimension;
2007     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2008   }
2009 }
2010
2011 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2012   return Dali::CustomActorImpl::GetExtension();
2013 }
2014
2015 void SwigDirector_ViewImpl::OnInitialize() {
2016   if (!swig_callbackOnInitialize) {
2017     Dali::Toolkit::Internal::Control::OnInitialize();
2018     return;
2019   } else {
2020     swig_callbackOnInitialize();
2021   }
2022 }
2023
2024 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2025   void * jchild = 0 ;
2026
2027   if (!swig_callbackOnControlChildAdd) {
2028     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2029     return;
2030   } else {
2031     jchild = (Dali::Actor *) &child;
2032     swig_callbackOnControlChildAdd(jchild);
2033   }
2034 }
2035
2036 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2037   void * jchild = 0 ;
2038
2039   if (!swig_callbackOnControlChildRemove) {
2040     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2041     return;
2042   } else {
2043     jchild = (Dali::Actor *) &child;
2044     swig_callbackOnControlChildRemove(jchild);
2045   }
2046 }
2047
2048 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2049   void * jstyleManager  ;
2050   int jchange  ;
2051
2052   if (!swig_callbackOnStyleChange) {
2053     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2054     return;
2055   } else {
2056     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2057     jchange = (int)change;
2058     swig_callbackOnStyleChange(jstyleManager, jchange);
2059   }
2060 }
2061
2062 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2063   bool c_result = SwigValueInit< bool >() ;
2064   unsigned int jresult = 0 ;
2065
2066   if (!swig_callbackOnAccessibilityActivated) {
2067     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2068   } else {
2069     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2070     c_result = jresult ? true : false;
2071   }
2072   return c_result;
2073 }
2074
2075 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2076   bool c_result = SwigValueInit< bool >() ;
2077   unsigned int jresult = 0 ;
2078   void * jgesture  ;
2079
2080   if (!swig_callbackOnAccessibilityPan) {
2081     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2082   } else {
2083     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2084     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2085     c_result = jresult ? true : false;
2086   }
2087   return c_result;
2088 }
2089
2090 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2091   bool c_result = SwigValueInit< bool >() ;
2092   unsigned int jresult = 0 ;
2093   void * jtouchEvent = 0 ;
2094
2095   if (!swig_callbackOnAccessibilityTouch) {
2096     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2097   } else {
2098     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2099     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2100     c_result = jresult ? true : false;
2101   }
2102   return c_result;
2103 }
2104
2105 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2106   bool c_result = SwigValueInit< bool >() ;
2107   unsigned int jresult = 0 ;
2108   unsigned int jisIncrease  ;
2109
2110   if (!swig_callbackOnAccessibilityValueChange) {
2111     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2112   } else {
2113     jisIncrease = isIncrease;
2114     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2115     c_result = jresult ? true : false;
2116   }
2117   return c_result;
2118 }
2119
2120 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2121   bool c_result = SwigValueInit< bool >() ;
2122   unsigned int jresult = 0 ;
2123
2124   if (!swig_callbackOnAccessibilityZoom) {
2125     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2126   } else {
2127     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2128     c_result = jresult ? true : false;
2129   }
2130   return c_result;
2131 }
2132
2133 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2134   if (!swig_callbackOnKeyInputFocusGained) {
2135     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2136     return;
2137   } else {
2138     swig_callbackOnKeyInputFocusGained();
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2143   if (!swig_callbackOnKeyInputFocusLost) {
2144     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2145     return;
2146   } else {
2147     swig_callbackOnKeyInputFocusLost();
2148   }
2149 }
2150
2151 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2152   Dali::Actor c_result ;
2153   void * jresult = 0 ;
2154   void * jcurrentFocusedActor  ;
2155   int jdirection  ;
2156   unsigned int jloopEnabled  ;
2157
2158   if (!swig_callbackGetNextKeyboardFocusableActor) {
2159     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2160   } else {
2161     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2162     jdirection = (int)direction;
2163     jloopEnabled = loopEnabled;
2164     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2165     if (!jresult) {
2166       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2167       return c_result;
2168     }
2169     c_result = *(Dali::Actor *)jresult;
2170   }
2171   return c_result;
2172 }
2173
2174 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2175   void * jcommitedFocusableActor  ;
2176
2177   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2178     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2179     return;
2180   } else {
2181     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2182     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2183   }
2184 }
2185
2186 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2187   bool c_result = SwigValueInit< bool >() ;
2188   unsigned int jresult = 0 ;
2189
2190   if (!swig_callbackOnKeyboardEnter) {
2191     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2192   } else {
2193     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2200   void * jpinch = 0 ;
2201
2202   if (!swig_callbackOnPinch) {
2203     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2204     return;
2205   } else {
2206     jpinch = (Dali::PinchGesture *) &pinch;
2207     swig_callbackOnPinch(jpinch);
2208   }
2209 }
2210
2211 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2212   void * jpan = 0 ;
2213
2214   if (!swig_callbackOnPan) {
2215     Dali::Toolkit::Internal::Control::OnPan(pan);
2216     return;
2217   } else {
2218     jpan = (Dali::PanGesture *) &pan;
2219     swig_callbackOnPan(jpan);
2220   }
2221 }
2222
2223 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2224   void * jtap = 0 ;
2225
2226   if (!swig_callbackOnTap) {
2227     Dali::Toolkit::Internal::Control::OnTap(tap);
2228     return;
2229   } else {
2230     jtap = (Dali::TapGesture *) &tap;
2231     swig_callbackOnTap(jtap);
2232   }
2233 }
2234
2235 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2236   void * jlongPress = 0 ;
2237
2238   if (!swig_callbackOnLongPress) {
2239     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2240     return;
2241   } else {
2242     jlongPress = (Dali::LongPressGesture *) &longPress;
2243     swig_callbackOnLongPress(jlongPress);
2244   }
2245 }
2246
2247 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2248   void * jslotObserver = 0 ;
2249   void * jcallback = 0 ;
2250
2251   if (!swig_callbackSignalConnected) {
2252     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2253     return;
2254   } else {
2255     jslotObserver = (void *) slotObserver;
2256     jcallback = (void *) callback;
2257     swig_callbackSignalConnected(jslotObserver, jcallback);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2262   void * jslotObserver = 0 ;
2263   void * jcallback = 0 ;
2264
2265   if (!swig_callbackSignalDisconnected) {
2266     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2267     return;
2268   } else {
2269     jslotObserver = (void *) slotObserver;
2270     jcallback = (void *) callback;
2271     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2272   }
2273 }
2274
2275 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2276   return Dali::Toolkit::Internal::Control::GetControlExtension();
2277 }
2278
2279 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2280   swig_callbackOnStageConnection = callbackOnStageConnection;
2281   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2282   swig_callbackOnChildAdd = callbackOnChildAdd;
2283   swig_callbackOnChildRemove = callbackOnChildRemove;
2284   swig_callbackOnPropertySet = callbackOnPropertySet;
2285   swig_callbackOnSizeSet = callbackOnSizeSet;
2286   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2287   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2288   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2289   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2290   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2291   swig_callbackOnRelayout = callbackOnRelayout;
2292   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2293   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2294   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2295   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2296   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2297   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2298   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2299   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2300   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2301   swig_callbackOnInitialize = callbackOnInitialize;
2302   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2303   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2304   swig_callbackOnStyleChange = callbackOnStyleChange;
2305   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2306   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2307   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2308   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2309   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2310   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2311   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2312   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2313   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2314   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2315   swig_callbackOnPinch = callbackOnPinch;
2316   swig_callbackOnPan = callbackOnPan;
2317   swig_callbackOnTap = callbackOnTap;
2318   swig_callbackOnLongPress = callbackOnLongPress;
2319   swig_callbackSignalConnected = callbackSignalConnected;
2320   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2321 }
2322
2323 void SwigDirector_ViewImpl::swig_init_callbacks() {
2324   swig_callbackOnStageConnection = 0;
2325   swig_callbackOnStageDisconnection = 0;
2326   swig_callbackOnChildAdd = 0;
2327   swig_callbackOnChildRemove = 0;
2328   swig_callbackOnPropertySet = 0;
2329   swig_callbackOnSizeSet = 0;
2330   swig_callbackOnSizeAnimation = 0;
2331   swig_callbackOnTouchEvent = 0;
2332   swig_callbackOnHoverEvent = 0;
2333   swig_callbackOnKeyEvent = 0;
2334   swig_callbackOnWheelEvent = 0;
2335   swig_callbackOnRelayout = 0;
2336   swig_callbackOnSetResizePolicy = 0;
2337   swig_callbackGetNaturalSize = 0;
2338   swig_callbackCalculateChildSize = 0;
2339   swig_callbackGetHeightForWidth = 0;
2340   swig_callbackGetWidthForHeight = 0;
2341   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2342   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2343   swig_callbackOnCalculateRelayoutSize = 0;
2344   swig_callbackOnLayoutNegotiated = 0;
2345   swig_callbackOnInitialize = 0;
2346   swig_callbackOnControlChildAdd = 0;
2347   swig_callbackOnControlChildRemove = 0;
2348   swig_callbackOnStyleChange = 0;
2349   swig_callbackOnAccessibilityActivated = 0;
2350   swig_callbackOnAccessibilityPan = 0;
2351   swig_callbackOnAccessibilityTouch = 0;
2352   swig_callbackOnAccessibilityValueChange = 0;
2353   swig_callbackOnAccessibilityZoom = 0;
2354   swig_callbackOnKeyInputFocusGained = 0;
2355   swig_callbackOnKeyInputFocusLost = 0;
2356   swig_callbackGetNextKeyboardFocusableActor = 0;
2357   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2358   swig_callbackOnKeyboardEnter = 0;
2359   swig_callbackOnPinch = 0;
2360   swig_callbackOnPan = 0;
2361   swig_callbackOnTap = 0;
2362   swig_callbackOnLongPress = 0;
2363   swig_callbackSignalConnected = 0;
2364   swig_callbackSignalDisconnected = 0;
2365 }
2366
2367 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2368   swig_init_callbacks();
2369 }
2370
2371 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2372
2373 }
2374
2375
2376 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2377   unsigned int c_result = SwigValueInit< unsigned int >() ;
2378   unsigned int jresult = 0 ;
2379
2380   if (!swig_callbackGetNumberOfItems) {
2381     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2382   } else {
2383     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2384     c_result = (unsigned int)jresult;
2385   }
2386   return c_result;
2387 }
2388
2389 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2390   Dali::Actor c_result ;
2391   void * jresult = 0 ;
2392   unsigned int jitemId  ;
2393
2394   if (!swig_callbackNewItem) {
2395     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2396   } else {
2397     jitemId = itemId;
2398     jresult = (void *) swig_callbackNewItem(jitemId);
2399     if (!jresult) {
2400       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2401       return c_result;
2402     }
2403     c_result = *(Dali::Actor *)jresult;
2404   }
2405   return c_result;
2406 }
2407
2408 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2409   unsigned int jitemId  ;
2410   void * jactor  ;
2411
2412   if (!swig_callbackItemReleased) {
2413     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2414     return;
2415   } else {
2416     jitemId = itemId;
2417     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2418     swig_callbackItemReleased(jitemId, jactor);
2419   }
2420 }
2421
2422 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2423   return Dali::Toolkit::ItemFactory::GetExtension();
2424 }
2425
2426 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2427   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2428   swig_callbackNewItem = callbackNewItem;
2429   swig_callbackItemReleased = callbackItemReleased;
2430 }
2431
2432 void SwigDirector_ItemFactory::swig_init_callbacks() {
2433   swig_callbackGetNumberOfItems = 0;
2434   swig_callbackNewItem = 0;
2435   swig_callbackItemReleased = 0;
2436 }
2437
2438 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2439   swig_init_callbacks();
2440 }
2441
2442 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2443
2444 }
2445
2446
2447 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2448   Dali::Actor c_result ;
2449   void * jresult = 0 ;
2450   void * jcurrent  ;
2451   void * jproposed  ;
2452   int jdirection  ;
2453
2454   if (!swig_callbackGetNextFocusableActor) {
2455     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2456   } else {
2457     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2458     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2459     jdirection = (int)direction;
2460     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2461     if (!jresult) {
2462       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2463       return c_result;
2464     }
2465     c_result = *(Dali::Actor *)jresult;
2466   }
2467   return c_result;
2468 }
2469
2470 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2471   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2472 }
2473
2474 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2475   swig_callbackGetNextFocusableActor = 0;
2476 }
2477
2478
2479 #ifdef __cplusplus
2480 extern "C" {
2481 #endif
2482
2483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2484   void * jresult ;
2485   floatp *result = 0 ;
2486
2487   {
2488     try {
2489       result = (floatp *)new_floatp();
2490     } catch (std::out_of_range& e) {
2491       {
2492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2493       };
2494     } catch (std::exception& e) {
2495       {
2496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2497       };
2498     } catch (...) {
2499       {
2500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2501       };
2502     }
2503   }
2504   jresult = (void *)result;
2505   return jresult;
2506 }
2507
2508
2509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2510   floatp *arg1 = (floatp *) 0 ;
2511
2512   arg1 = (floatp *)jarg1;
2513   {
2514     try {
2515       delete_floatp(arg1);
2516     } catch (std::out_of_range& e) {
2517       {
2518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2519       };
2520     } catch (std::exception& e) {
2521       {
2522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2523       };
2524     } catch (...) {
2525       {
2526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2527       };
2528     }
2529   }
2530 }
2531
2532
2533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2534   floatp *arg1 = (floatp *) 0 ;
2535   float arg2 ;
2536
2537   arg1 = (floatp *)jarg1;
2538   arg2 = (float)jarg2;
2539   {
2540     try {
2541       floatp_assign(arg1,arg2);
2542     } catch (std::out_of_range& e) {
2543       {
2544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2545       };
2546     } catch (std::exception& e) {
2547       {
2548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2549       };
2550     } catch (...) {
2551       {
2552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2553       };
2554     }
2555   }
2556 }
2557
2558
2559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2560   float jresult ;
2561   floatp *arg1 = (floatp *) 0 ;
2562   float result;
2563
2564   arg1 = (floatp *)jarg1;
2565   {
2566     try {
2567       result = (float)floatp_value(arg1);
2568     } catch (std::out_of_range& e) {
2569       {
2570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2571       };
2572     } catch (std::exception& e) {
2573       {
2574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2575       };
2576     } catch (...) {
2577       {
2578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2579       };
2580     }
2581   }
2582   jresult = result;
2583   return jresult;
2584 }
2585
2586
2587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2588   void * jresult ;
2589   floatp *arg1 = (floatp *) 0 ;
2590   float *result = 0 ;
2591
2592   arg1 = (floatp *)jarg1;
2593   {
2594     try {
2595       result = (float *)floatp_cast(arg1);
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (...) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2607       };
2608     }
2609   }
2610   jresult = (void *)result;
2611   return jresult;
2612 }
2613
2614
2615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2616   void * jresult ;
2617   float *arg1 = (float *) 0 ;
2618   floatp *result = 0 ;
2619
2620   arg1 = (float *)jarg1;
2621   {
2622     try {
2623       result = (floatp *)floatp_frompointer(arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (...) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2635       };
2636     }
2637   }
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2644   void * jresult ;
2645   intp *result = 0 ;
2646
2647   {
2648     try {
2649       result = (intp *)new_intp();
2650     } catch (std::out_of_range& e) {
2651       {
2652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2653       };
2654     } catch (std::exception& e) {
2655       {
2656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2657       };
2658     } catch (...) {
2659       {
2660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2661       };
2662     }
2663   }
2664   jresult = (void *)result;
2665   return jresult;
2666 }
2667
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2670   intp *arg1 = (intp *) 0 ;
2671
2672   arg1 = (intp *)jarg1;
2673   {
2674     try {
2675       delete_intp(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (...) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2687       };
2688     }
2689   }
2690 }
2691
2692
2693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2694   intp *arg1 = (intp *) 0 ;
2695   int arg2 ;
2696
2697   arg1 = (intp *)jarg1;
2698   arg2 = (int)jarg2;
2699   {
2700     try {
2701       intp_assign(arg1,arg2);
2702     } catch (std::out_of_range& e) {
2703       {
2704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2705       };
2706     } catch (std::exception& e) {
2707       {
2708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2709       };
2710     } catch (...) {
2711       {
2712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2713       };
2714     }
2715   }
2716 }
2717
2718
2719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2720   int jresult ;
2721   intp *arg1 = (intp *) 0 ;
2722   int result;
2723
2724   arg1 = (intp *)jarg1;
2725   {
2726     try {
2727       result = (int)intp_value(arg1);
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (...) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2739       };
2740     }
2741   }
2742   jresult = result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2748   void * jresult ;
2749   intp *arg1 = (intp *) 0 ;
2750   int *result = 0 ;
2751
2752   arg1 = (intp *)jarg1;
2753   {
2754     try {
2755       result = (int *)intp_cast(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (...) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2767       };
2768     }
2769   }
2770   jresult = (void *)result;
2771   return jresult;
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2776   void * jresult ;
2777   int *arg1 = (int *) 0 ;
2778   intp *result = 0 ;
2779
2780   arg1 = (int *)jarg1;
2781   {
2782     try {
2783       result = (intp *)intp_frompointer(arg1);
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (...) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2795       };
2796     }
2797   }
2798   jresult = (void *)result;
2799   return jresult;
2800 }
2801
2802
2803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2804   void * jresult ;
2805   doublep *result = 0 ;
2806
2807   {
2808     try {
2809       result = (doublep *)new_doublep();
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2817       };
2818     } catch (...) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2821       };
2822     }
2823   }
2824   jresult = (void *)result;
2825   return jresult;
2826 }
2827
2828
2829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2830   doublep *arg1 = (doublep *) 0 ;
2831
2832   arg1 = (doublep *)jarg1;
2833   {
2834     try {
2835       delete_doublep(arg1);
2836     } catch (std::out_of_range& e) {
2837       {
2838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2839       };
2840     } catch (std::exception& e) {
2841       {
2842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (...) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2847       };
2848     }
2849   }
2850 }
2851
2852
2853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2854   doublep *arg1 = (doublep *) 0 ;
2855   double arg2 ;
2856
2857   arg1 = (doublep *)jarg1;
2858   arg2 = (double)jarg2;
2859   {
2860     try {
2861       doublep_assign(arg1,arg2);
2862     } catch (std::out_of_range& e) {
2863       {
2864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2865       };
2866     } catch (std::exception& e) {
2867       {
2868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2869       };
2870     } catch (...) {
2871       {
2872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2873       };
2874     }
2875   }
2876 }
2877
2878
2879 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2880   double jresult ;
2881   doublep *arg1 = (doublep *) 0 ;
2882   double result;
2883
2884   arg1 = (doublep *)jarg1;
2885   {
2886     try {
2887       result = (double)doublep_value(arg1);
2888     } catch (std::out_of_range& e) {
2889       {
2890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2891       };
2892     } catch (std::exception& e) {
2893       {
2894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2895       };
2896     } catch (...) {
2897       {
2898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2899       };
2900     }
2901   }
2902   jresult = result;
2903   return jresult;
2904 }
2905
2906
2907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2908   void * jresult ;
2909   doublep *arg1 = (doublep *) 0 ;
2910   double *result = 0 ;
2911
2912   arg1 = (doublep *)jarg1;
2913   {
2914     try {
2915       result = (double *)doublep_cast(arg1);
2916     } catch (std::out_of_range& e) {
2917       {
2918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2919       };
2920     } catch (std::exception& e) {
2921       {
2922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2923       };
2924     } catch (...) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2927       };
2928     }
2929   }
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2936   void * jresult ;
2937   double *arg1 = (double *) 0 ;
2938   doublep *result = 0 ;
2939
2940   arg1 = (double *)jarg1;
2941   {
2942     try {
2943       result = (doublep *)doublep_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (...) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2955       };
2956     }
2957   }
2958   jresult = (void *)result;
2959   return jresult;
2960 }
2961
2962
2963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2964   void * jresult ;
2965   uintp *result = 0 ;
2966
2967   {
2968     try {
2969       result = (uintp *)new_uintp();
2970     } catch (std::out_of_range& e) {
2971       {
2972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2973       };
2974     } catch (std::exception& e) {
2975       {
2976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (...) {
2979       {
2980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2981       };
2982     }
2983   }
2984   jresult = (void *)result;
2985   return jresult;
2986 }
2987
2988
2989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2990   uintp *arg1 = (uintp *) 0 ;
2991
2992   arg1 = (uintp *)jarg1;
2993   {
2994     try {
2995       delete_uintp(arg1);
2996     } catch (std::out_of_range& e) {
2997       {
2998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (std::exception& e) {
3001       {
3002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010 }
3011
3012
3013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3014   uintp *arg1 = (uintp *) 0 ;
3015   unsigned int arg2 ;
3016
3017   arg1 = (uintp *)jarg1;
3018   arg2 = (unsigned int)jarg2;
3019   {
3020     try {
3021       uintp_assign(arg1,arg2);
3022     } catch (std::out_of_range& e) {
3023       {
3024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3025       };
3026     } catch (std::exception& e) {
3027       {
3028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3029       };
3030     } catch (...) {
3031       {
3032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3033       };
3034     }
3035   }
3036 }
3037
3038
3039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3040   unsigned int jresult ;
3041   uintp *arg1 = (uintp *) 0 ;
3042   unsigned int result;
3043
3044   arg1 = (uintp *)jarg1;
3045   {
3046     try {
3047       result = (unsigned int)uintp_value(arg1);
3048     } catch (std::out_of_range& e) {
3049       {
3050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3051       };
3052     } catch (std::exception& e) {
3053       {
3054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3059       };
3060     }
3061   }
3062   jresult = result;
3063   return jresult;
3064 }
3065
3066
3067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3068   void * jresult ;
3069   uintp *arg1 = (uintp *) 0 ;
3070   unsigned int *result = 0 ;
3071
3072   arg1 = (uintp *)jarg1;
3073   {
3074     try {
3075       result = (unsigned int *)uintp_cast(arg1);
3076     } catch (std::out_of_range& e) {
3077       {
3078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3079       };
3080     } catch (std::exception& e) {
3081       {
3082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3083       };
3084     } catch (...) {
3085       {
3086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3087       };
3088     }
3089   }
3090   jresult = (void *)result;
3091   return jresult;
3092 }
3093
3094
3095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3096   void * jresult ;
3097   unsigned int *arg1 = (unsigned int *) 0 ;
3098   uintp *result = 0 ;
3099
3100   arg1 = (unsigned int *)jarg1;
3101   {
3102     try {
3103       result = (uintp *)uintp_frompointer(arg1);
3104     } catch (std::out_of_range& e) {
3105       {
3106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (std::exception& e) {
3109       {
3110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118   jresult = (void *)result;
3119   return jresult;
3120 }
3121
3122
3123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3124   void * jresult ;
3125   ushortp *result = 0 ;
3126
3127   {
3128     try {
3129       result = (ushortp *)new_ushortp();
3130     } catch (std::out_of_range& e) {
3131       {
3132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (std::exception& e) {
3135       {
3136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (...) {
3139       {
3140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3141       };
3142     }
3143   }
3144   jresult = (void *)result;
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3150   ushortp *arg1 = (ushortp *) 0 ;
3151
3152   arg1 = (ushortp *)jarg1;
3153   {
3154     try {
3155       delete_ushortp(arg1);
3156     } catch (std::out_of_range& e) {
3157       {
3158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3159       };
3160     } catch (std::exception& e) {
3161       {
3162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3163       };
3164     } catch (...) {
3165       {
3166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3167       };
3168     }
3169   }
3170 }
3171
3172
3173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3174   ushortp *arg1 = (ushortp *) 0 ;
3175   unsigned short arg2 ;
3176
3177   arg1 = (ushortp *)jarg1;
3178   arg2 = (unsigned short)jarg2;
3179   {
3180     try {
3181       ushortp_assign(arg1,arg2);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (...) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3193       };
3194     }
3195   }
3196 }
3197
3198
3199 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3200   unsigned short jresult ;
3201   ushortp *arg1 = (ushortp *) 0 ;
3202   unsigned short result;
3203
3204   arg1 = (ushortp *)jarg1;
3205   {
3206     try {
3207       result = (unsigned short)ushortp_value(arg1);
3208     } catch (std::out_of_range& e) {
3209       {
3210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3211       };
3212     } catch (std::exception& e) {
3213       {
3214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (...) {
3217       {
3218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3219       };
3220     }
3221   }
3222   jresult = result;
3223   return jresult;
3224 }
3225
3226
3227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3228   void * jresult ;
3229   ushortp *arg1 = (ushortp *) 0 ;
3230   unsigned short *result = 0 ;
3231
3232   arg1 = (ushortp *)jarg1;
3233   {
3234     try {
3235       result = (unsigned short *)ushortp_cast(arg1);
3236     } catch (std::out_of_range& e) {
3237       {
3238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3239       };
3240     } catch (std::exception& e) {
3241       {
3242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3243       };
3244     } catch (...) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3247       };
3248     }
3249   }
3250   jresult = (void *)result;
3251   return jresult;
3252 }
3253
3254
3255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3256   void * jresult ;
3257   unsigned short *arg1 = (unsigned short *) 0 ;
3258   ushortp *result = 0 ;
3259
3260   arg1 = (unsigned short *)jarg1;
3261   {
3262     try {
3263       result = (ushortp *)ushortp_frompointer(arg1);
3264     } catch (std::out_of_range& e) {
3265       {
3266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (std::exception& e) {
3269       {
3270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278   jresult = (void *)result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3284   unsigned int jresult ;
3285   int arg1 ;
3286   unsigned int result;
3287
3288   arg1 = (int)jarg1;
3289   {
3290     try {
3291       result = (unsigned int)int_to_uint(arg1);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3312   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3313
3314   arg1 = (Dali::RefObject *)jarg1;
3315   {
3316     try {
3317       (arg1)->Reference();
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (...) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3329       };
3330     }
3331   }
3332 }
3333
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3336   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3337
3338   arg1 = (Dali::RefObject *)jarg1;
3339   {
3340     try {
3341       (arg1)->Unreference();
3342     } catch (std::out_of_range& e) {
3343       {
3344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (std::exception& e) {
3347       {
3348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3349       };
3350     } catch (...) {
3351       {
3352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3353       };
3354     }
3355   }
3356 }
3357
3358
3359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3360   int jresult ;
3361   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3362   int result;
3363
3364   arg1 = (Dali::RefObject *)jarg1;
3365   {
3366     try {
3367       result = (int)(arg1)->ReferenceCount();
3368     } catch (std::out_of_range& e) {
3369       {
3370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3371       };
3372     } catch (std::exception& e) {
3373       {
3374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3375       };
3376     } catch (...) {
3377       {
3378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3379       };
3380     }
3381   }
3382   jresult = result;
3383   return jresult;
3384 }
3385
3386
3387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3388   void * jresult ;
3389   Dali::Any *result = 0 ;
3390
3391   {
3392     try {
3393       result = (Dali::Any *)new Dali::Any();
3394     } catch (std::out_of_range& e) {
3395       {
3396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3397       };
3398     } catch (std::exception& e) {
3399       {
3400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3401       };
3402     } catch (...) {
3403       {
3404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3405       };
3406     }
3407   }
3408   jresult = (void *)result;
3409   return jresult;
3410 }
3411
3412
3413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3414   Dali::Any *arg1 = (Dali::Any *) 0 ;
3415
3416   arg1 = (Dali::Any *)jarg1;
3417   {
3418     try {
3419       delete arg1;
3420     } catch (std::out_of_range& e) {
3421       {
3422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (std::exception& e) {
3425       {
3426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434 }
3435
3436
3437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3438   char *arg1 = (char *) 0 ;
3439
3440   arg1 = (char *)jarg1;
3441   {
3442     try {
3443       Dali::Any::AssertAlways((char const *)arg1);
3444     } catch (std::out_of_range& e) {
3445       {
3446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3447       };
3448     } catch (std::exception& e) {
3449       {
3450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3451       };
3452     } catch (...) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3455       };
3456     }
3457   }
3458 }
3459
3460
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3462   void * jresult ;
3463   Dali::Any *arg1 = 0 ;
3464   Dali::Any *result = 0 ;
3465
3466   arg1 = (Dali::Any *)jarg1;
3467   if (!arg1) {
3468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3469     return 0;
3470   }
3471   {
3472     try {
3473       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3474     } catch (std::out_of_range& e) {
3475       {
3476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (std::exception& e) {
3479       {
3480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3481       };
3482     } catch (...) {
3483       {
3484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3485       };
3486     }
3487   }
3488   jresult = (void *)result;
3489   return jresult;
3490 }
3491
3492
3493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3494   void * jresult ;
3495   Dali::Any *arg1 = (Dali::Any *) 0 ;
3496   Dali::Any *arg2 = 0 ;
3497   Dali::Any *result = 0 ;
3498
3499   arg1 = (Dali::Any *)jarg1;
3500   arg2 = (Dali::Any *)jarg2;
3501   if (!arg2) {
3502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3503     return 0;
3504   }
3505   {
3506     try {
3507       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3508     } catch (std::out_of_range& e) {
3509       {
3510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3511       };
3512     } catch (std::exception& e) {
3513       {
3514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (...) {
3517       {
3518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3519       };
3520     }
3521   }
3522   jresult = (void *)result;
3523   return jresult;
3524 }
3525
3526
3527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3528   void * jresult ;
3529   Dali::Any *arg1 = (Dali::Any *) 0 ;
3530   std::type_info *result = 0 ;
3531
3532   arg1 = (Dali::Any *)jarg1;
3533   {
3534     try {
3535       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3536     } catch (std::out_of_range& e) {
3537       {
3538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3539       };
3540     } catch (std::exception& e) {
3541       {
3542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (...) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3547       };
3548     }
3549   }
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3556   unsigned int jresult ;
3557   Dali::Any *arg1 = (Dali::Any *) 0 ;
3558   bool result;
3559
3560   arg1 = (Dali::Any *)jarg1;
3561   {
3562     try {
3563       result = (bool)((Dali::Any const *)arg1)->Empty();
3564     } catch (std::out_of_range& e) {
3565       {
3566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3567       };
3568     } catch (std::exception& e) {
3569       {
3570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3575       };
3576     }
3577   }
3578   jresult = result;
3579   return jresult;
3580 }
3581
3582
3583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3584   void * jresult ;
3585   std::type_info *arg1 = 0 ;
3586   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3587   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3588   Dali::Any::AnyContainerBase *result = 0 ;
3589
3590   arg1 = (std::type_info *)jarg1;
3591   if (!arg1) {
3592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3593     return 0;
3594   }
3595   arg2 = (Dali::Any::CloneFunc)jarg2;
3596   arg3 = (Dali::Any::DeleteFunc)jarg3;
3597   {
3598     try {
3599       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3600     } catch (std::out_of_range& e) {
3601       {
3602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3603       };
3604     } catch (std::exception& e) {
3605       {
3606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3607       };
3608     } catch (...) {
3609       {
3610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3611       };
3612     }
3613   }
3614   jresult = (void *)result;
3615   return jresult;
3616 }
3617
3618
3619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3620   void * jresult ;
3621   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3622   std::type_info *result = 0 ;
3623
3624   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3625   {
3626     try {
3627       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3628     } catch (std::out_of_range& e) {
3629       {
3630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (std::exception& e) {
3633       {
3634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3648   void * jresult ;
3649   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3650   ::std::type_info *result = 0 ;
3651
3652   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3653   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3654   jresult = (void *)result;
3655   return jresult;
3656 }
3657
3658
3659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3660   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3661   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3662
3663   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3664   arg2 = (Dali::Any::CloneFunc)jarg2;
3665   if (arg1) (arg1)->mCloneFunc = arg2;
3666 }
3667
3668
3669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3670   void * jresult ;
3671   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3672   Dali::Any::CloneFunc result;
3673
3674   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3675   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3676   jresult = (void *)result;
3677   return jresult;
3678 }
3679
3680
3681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3682   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3683   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3684
3685   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3686   arg2 = (Dali::Any::DeleteFunc)jarg2;
3687   if (arg1) (arg1)->mDeleteFunc = arg2;
3688 }
3689
3690
3691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3692   void * jresult ;
3693   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3694   Dali::Any::DeleteFunc result;
3695
3696   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3697   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3698   jresult = (void *)result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3704   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3705
3706   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3707   {
3708     try {
3709       delete arg1;
3710     } catch (std::out_of_range& e) {
3711       {
3712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3713       };
3714     } catch (std::exception& e) {
3715       {
3716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3717       };
3718     } catch (...) {
3719       {
3720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3721       };
3722     }
3723   }
3724 }
3725
3726
3727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3728   Dali::Any *arg1 = (Dali::Any *) 0 ;
3729   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3730
3731   arg1 = (Dali::Any *)jarg1;
3732   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3733   if (arg1) (arg1)->mContainer = arg2;
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3738   void * jresult ;
3739   Dali::Any *arg1 = (Dali::Any *) 0 ;
3740   Dali::Any::AnyContainerBase *result = 0 ;
3741
3742   arg1 = (Dali::Any *)jarg1;
3743   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3744   jresult = (void *)result;
3745   return jresult;
3746 }
3747
3748
3749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3750   char *arg1 = (char *) 0 ;
3751   char *arg2 = (char *) 0 ;
3752
3753   arg1 = (char *)jarg1;
3754   arg2 = (char *)jarg2;
3755   {
3756     try {
3757       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3765       };
3766     } catch (...) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3769       };
3770     }
3771   }
3772 }
3773
3774
3775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3776   void * jresult ;
3777   char *arg1 = (char *) 0 ;
3778   char *arg2 = (char *) 0 ;
3779   Dali::DaliException *result = 0 ;
3780
3781   arg1 = (char *)jarg1;
3782   arg2 = (char *)jarg2;
3783   {
3784     try {
3785       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3786     } catch (std::out_of_range& e) {
3787       {
3788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3789       };
3790     } catch (std::exception& e) {
3791       {
3792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3793       };
3794     } catch (...) {
3795       {
3796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3797       };
3798     }
3799   }
3800   jresult = (void *)result;
3801   return jresult;
3802 }
3803
3804
3805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3806   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3807   char *arg2 = (char *) 0 ;
3808
3809   arg1 = (Dali::DaliException *)jarg1;
3810   arg2 = (char *)jarg2;
3811   {
3812     if (arg2) {
3813       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3814       strcpy((char *)arg1->location, (const char *)arg2);
3815     } else {
3816       arg1->location = 0;
3817     }
3818   }
3819 }
3820
3821
3822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3823   char * jresult ;
3824   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3825   char *result = 0 ;
3826
3827   arg1 = (Dali::DaliException *)jarg1;
3828   result = (char *) ((arg1)->location);
3829   jresult = SWIG_csharp_string_callback((const char *)result);
3830   return jresult;
3831 }
3832
3833
3834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3835   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3836   char *arg2 = (char *) 0 ;
3837
3838   arg1 = (Dali::DaliException *)jarg1;
3839   arg2 = (char *)jarg2;
3840   {
3841     if (arg2) {
3842       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3843       strcpy((char *)arg1->condition, (const char *)arg2);
3844     } else {
3845       arg1->condition = 0;
3846     }
3847   }
3848 }
3849
3850
3851 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3852   char * jresult ;
3853   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3854   char *result = 0 ;
3855
3856   arg1 = (Dali::DaliException *)jarg1;
3857   result = (char *) ((arg1)->condition);
3858   jresult = SWIG_csharp_string_callback((const char *)result);
3859   return jresult;
3860 }
3861
3862
3863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3864   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3865
3866   arg1 = (Dali::DaliException *)jarg1;
3867   {
3868     try {
3869       delete arg1;
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3881       };
3882     }
3883   }
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3888   void * jresult ;
3889   Dali::Vector2 *result = 0 ;
3890
3891   {
3892     try {
3893       result = (Dali::Vector2 *)new Dali::Vector2();
3894     } catch (std::out_of_range& e) {
3895       {
3896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3897       };
3898     } catch (std::exception& e) {
3899       {
3900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (...) {
3903       {
3904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3905       };
3906     }
3907   }
3908   jresult = (void *)result;
3909   return jresult;
3910 }
3911
3912
3913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3914   void * jresult ;
3915   float arg1 ;
3916   float arg2 ;
3917   Dali::Vector2 *result = 0 ;
3918
3919   arg1 = (float)jarg1;
3920   arg2 = (float)jarg2;
3921   {
3922     try {
3923       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3924     } catch (std::out_of_range& e) {
3925       {
3926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3927       };
3928     } catch (std::exception& e) {
3929       {
3930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3931       };
3932     } catch (...) {
3933       {
3934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3935       };
3936     }
3937   }
3938   jresult = (void *)result;
3939   return jresult;
3940 }
3941
3942
3943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3944   void * jresult ;
3945   float *arg1 = (float *) 0 ;
3946   Dali::Vector2 *result = 0 ;
3947
3948   arg1 = jarg1;
3949   {
3950     try {
3951       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3952     } catch (std::out_of_range& e) {
3953       {
3954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3955       };
3956     } catch (std::exception& e) {
3957       {
3958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3959       };
3960     } catch (...) {
3961       {
3962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3963       };
3964     }
3965   }
3966   jresult = (void *)result;
3967
3968
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3974   void * jresult ;
3975   Dali::Vector3 *arg1 = 0 ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   arg1 = (Dali::Vector3 *)jarg1;
3979   if (!arg1) {
3980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3981     return 0;
3982   }
3983   {
3984     try {
3985       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3986     } catch (std::out_of_range& e) {
3987       {
3988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3989       };
3990     } catch (std::exception& e) {
3991       {
3992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3993       };
3994     } catch (...) {
3995       {
3996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3997       };
3998     }
3999   }
4000   jresult = (void *)result;
4001   return jresult;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4006   void * jresult ;
4007   Dali::Vector4 *arg1 = 0 ;
4008   Dali::Vector2 *result = 0 ;
4009
4010   arg1 = (Dali::Vector4 *)jarg1;
4011   if (!arg1) {
4012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4013     return 0;
4014   }
4015   {
4016     try {
4017       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4018     } catch (std::out_of_range& e) {
4019       {
4020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4021       };
4022     } catch (std::exception& e) {
4023       {
4024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4025       };
4026     } catch (...) {
4027       {
4028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4029       };
4030     }
4031   }
4032   jresult = (void *)result;
4033   return jresult;
4034 }
4035
4036
4037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4038   void * jresult ;
4039   Dali::Vector2 *result = 0 ;
4040
4041   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4042   jresult = (void *)result;
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4048   void * jresult ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4052   jresult = (void *)result;
4053   return jresult;
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4058   void * jresult ;
4059   Dali::Vector2 *result = 0 ;
4060
4061   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4062   jresult = (void *)result;
4063   return jresult;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4068   void * jresult ;
4069   Dali::Vector2 *result = 0 ;
4070
4071   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4072   jresult = (void *)result;
4073   return jresult;
4074 }
4075
4076
4077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4078   void * jresult ;
4079   Dali::Vector2 *result = 0 ;
4080
4081   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4082   jresult = (void *)result;
4083   return jresult;
4084 }
4085
4086
4087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4088   void * jresult ;
4089   Dali::Vector2 *result = 0 ;
4090
4091   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4092   jresult = (void *)result;
4093   return jresult;
4094 }
4095
4096
4097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4098   void * jresult ;
4099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4100   float *arg2 = (float *) 0 ;
4101   Dali::Vector2 *result = 0 ;
4102
4103   arg1 = (Dali::Vector2 *)jarg1;
4104   arg2 = jarg2;
4105   {
4106     try {
4107       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4108     } catch (std::out_of_range& e) {
4109       {
4110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4111       };
4112     } catch (std::exception& e) {
4113       {
4114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (...) {
4117       {
4118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4119       };
4120     }
4121   }
4122   jresult = (void *)result;
4123
4124
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4130   void * jresult ;
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   Dali::Vector3 *arg2 = 0 ;
4133   Dali::Vector2 *result = 0 ;
4134
4135   arg1 = (Dali::Vector2 *)jarg1;
4136   arg2 = (Dali::Vector3 *)jarg2;
4137   if (!arg2) {
4138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4139     return 0;
4140   }
4141   {
4142     try {
4143       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4144     } catch (std::out_of_range& e) {
4145       {
4146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4147       };
4148     } catch (std::exception& e) {
4149       {
4150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4151       };
4152     } catch (...) {
4153       {
4154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4155       };
4156     }
4157   }
4158   jresult = (void *)result;
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4164   void * jresult ;
4165   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4166   Dali::Vector4 *arg2 = 0 ;
4167   Dali::Vector2 *result = 0 ;
4168
4169   arg1 = (Dali::Vector2 *)jarg1;
4170   arg2 = (Dali::Vector4 *)jarg2;
4171   if (!arg2) {
4172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4173     return 0;
4174   }
4175   {
4176     try {
4177       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4178     } catch (std::out_of_range& e) {
4179       {
4180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4181       };
4182     } catch (std::exception& e) {
4183       {
4184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (...) {
4187       {
4188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4189       };
4190     }
4191   }
4192   jresult = (void *)result;
4193   return jresult;
4194 }
4195
4196
4197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4198   void * jresult ;
4199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4200   Dali::Vector2 *arg2 = 0 ;
4201   Dali::Vector2 result;
4202
4203   arg1 = (Dali::Vector2 *)jarg1;
4204   arg2 = (Dali::Vector2 *)jarg2;
4205   if (!arg2) {
4206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4207     return 0;
4208   }
4209   {
4210     try {
4211       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4212     } catch (std::out_of_range& e) {
4213       {
4214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4215       };
4216     } catch (std::exception& e) {
4217       {
4218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4219       };
4220     } catch (...) {
4221       {
4222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4223       };
4224     }
4225   }
4226   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4232   void * jresult ;
4233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4234   Dali::Vector2 *arg2 = 0 ;
4235   Dali::Vector2 *result = 0 ;
4236
4237   arg1 = (Dali::Vector2 *)jarg1;
4238   arg2 = (Dali::Vector2 *)jarg2;
4239   if (!arg2) {
4240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4241     return 0;
4242   }
4243   {
4244     try {
4245       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4246     } catch (std::out_of_range& e) {
4247       {
4248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (std::exception& e) {
4251       {
4252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (...) {
4255       {
4256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4257       };
4258     }
4259   }
4260   jresult = (void *)result;
4261   return jresult;
4262 }
4263
4264
4265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4266   void * jresult ;
4267   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4268   Dali::Vector2 *arg2 = 0 ;
4269   Dali::Vector2 result;
4270
4271   arg1 = (Dali::Vector2 *)jarg1;
4272   arg2 = (Dali::Vector2 *)jarg2;
4273   if (!arg2) {
4274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4275     return 0;
4276   }
4277   {
4278     try {
4279       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4280     } catch (std::out_of_range& e) {
4281       {
4282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4283       };
4284     } catch (std::exception& e) {
4285       {
4286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4287       };
4288     } catch (...) {
4289       {
4290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4291       };
4292     }
4293   }
4294   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4295   return jresult;
4296 }
4297
4298
4299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4300   void * jresult ;
4301   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4302   Dali::Vector2 *arg2 = 0 ;
4303   Dali::Vector2 *result = 0 ;
4304
4305   arg1 = (Dali::Vector2 *)jarg1;
4306   arg2 = (Dali::Vector2 *)jarg2;
4307   if (!arg2) {
4308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4309     return 0;
4310   }
4311   {
4312     try {
4313       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4314     } catch (std::out_of_range& e) {
4315       {
4316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (std::exception& e) {
4319       {
4320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4321       };
4322     } catch (...) {
4323       {
4324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4325       };
4326     }
4327   }
4328   jresult = (void *)result;
4329   return jresult;
4330 }
4331
4332
4333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4334   void * jresult ;
4335   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4336   Dali::Vector2 *arg2 = 0 ;
4337   Dali::Vector2 result;
4338
4339   arg1 = (Dali::Vector2 *)jarg1;
4340   arg2 = (Dali::Vector2 *)jarg2;
4341   if (!arg2) {
4342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4343     return 0;
4344   }
4345   {
4346     try {
4347       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4348     } catch (std::out_of_range& e) {
4349       {
4350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4351       };
4352     } catch (std::exception& e) {
4353       {
4354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4355       };
4356     } catch (...) {
4357       {
4358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4359       };
4360     }
4361   }
4362   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4368   void * jresult ;
4369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4370   float arg2 ;
4371   Dali::Vector2 result;
4372
4373   arg1 = (Dali::Vector2 *)jarg1;
4374   arg2 = (float)jarg2;
4375   {
4376     try {
4377       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4378     } catch (std::out_of_range& e) {
4379       {
4380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (std::exception& e) {
4383       {
4384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4385       };
4386     } catch (...) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4389       };
4390     }
4391   }
4392   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4398   void * jresult ;
4399   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4400   Dali::Vector2 *arg2 = 0 ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   arg1 = (Dali::Vector2 *)jarg1;
4404   arg2 = (Dali::Vector2 *)jarg2;
4405   if (!arg2) {
4406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4407     return 0;
4408   }
4409   {
4410     try {
4411       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4412     } catch (std::out_of_range& e) {
4413       {
4414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4415       };
4416     } catch (std::exception& e) {
4417       {
4418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4419       };
4420     } catch (...) {
4421       {
4422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4423       };
4424     }
4425   }
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4432   void * jresult ;
4433   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4434   float arg2 ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   arg1 = (Dali::Vector2 *)jarg1;
4438   arg2 = (float)jarg2;
4439   {
4440     try {
4441       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4442     } catch (std::out_of_range& e) {
4443       {
4444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4445       };
4446     } catch (std::exception& e) {
4447       {
4448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (...) {
4451       {
4452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4453       };
4454     }
4455   }
4456   jresult = (void *)result;
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4462   void * jresult ;
4463   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4464   Dali::Vector2 *arg2 = 0 ;
4465   Dali::Vector2 result;
4466
4467   arg1 = (Dali::Vector2 *)jarg1;
4468   arg2 = (Dali::Vector2 *)jarg2;
4469   if (!arg2) {
4470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4471     return 0;
4472   }
4473   {
4474     try {
4475       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4476     } catch (std::out_of_range& e) {
4477       {
4478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4479       };
4480     } catch (std::exception& e) {
4481       {
4482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4483       };
4484     } catch (...) {
4485       {
4486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4487       };
4488     }
4489   }
4490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4491   return jresult;
4492 }
4493
4494
4495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4496   void * jresult ;
4497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4498   float arg2 ;
4499   Dali::Vector2 result;
4500
4501   arg1 = (Dali::Vector2 *)jarg1;
4502   arg2 = (float)jarg2;
4503   {
4504     try {
4505       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4506     } catch (std::out_of_range& e) {
4507       {
4508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (std::exception& e) {
4511       {
4512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (...) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4517       };
4518     }
4519   }
4520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4526   void * jresult ;
4527   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4528   Dali::Vector2 *arg2 = 0 ;
4529   Dali::Vector2 *result = 0 ;
4530
4531   arg1 = (Dali::Vector2 *)jarg1;
4532   arg2 = (Dali::Vector2 *)jarg2;
4533   if (!arg2) {
4534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4535     return 0;
4536   }
4537   {
4538     try {
4539       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4540     } catch (std::out_of_range& e) {
4541       {
4542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4543       };
4544     } catch (std::exception& e) {
4545       {
4546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (...) {
4549       {
4550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4551       };
4552     }
4553   }
4554   jresult = (void *)result;
4555   return jresult;
4556 }
4557
4558
4559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4560   void * jresult ;
4561   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4562   float arg2 ;
4563   Dali::Vector2 *result = 0 ;
4564
4565   arg1 = (Dali::Vector2 *)jarg1;
4566   arg2 = (float)jarg2;
4567   {
4568     try {
4569       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4570     } catch (std::out_of_range& e) {
4571       {
4572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (std::exception& e) {
4575       {
4576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4577       };
4578     } catch (...) {
4579       {
4580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4581       };
4582     }
4583   }
4584   jresult = (void *)result;
4585   return jresult;
4586 }
4587
4588
4589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4590   void * jresult ;
4591   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4592   Dali::Vector2 result;
4593
4594   arg1 = (Dali::Vector2 *)jarg1;
4595   {
4596     try {
4597       result = ((Dali::Vector2 const *)arg1)->operator -();
4598     } catch (std::out_of_range& e) {
4599       {
4600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (std::exception& e) {
4603       {
4604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4605       };
4606     } catch (...) {
4607       {
4608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4609       };
4610     }
4611   }
4612   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4613   return jresult;
4614 }
4615
4616
4617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4618   unsigned int jresult ;
4619   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4620   Dali::Vector2 *arg2 = 0 ;
4621   bool result;
4622
4623   arg1 = (Dali::Vector2 *)jarg1;
4624   arg2 = (Dali::Vector2 *)jarg2;
4625   if (!arg2) {
4626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4627     return 0;
4628   }
4629   {
4630     try {
4631       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4632     } catch (std::out_of_range& e) {
4633       {
4634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (std::exception& e) {
4637       {
4638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646   jresult = result;
4647   return jresult;
4648 }
4649
4650
4651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4652   unsigned int jresult ;
4653   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4654   Dali::Vector2 *arg2 = 0 ;
4655   bool result;
4656
4657   arg1 = (Dali::Vector2 *)jarg1;
4658   arg2 = (Dali::Vector2 *)jarg2;
4659   if (!arg2) {
4660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4661     return 0;
4662   }
4663   {
4664     try {
4665       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4666     } catch (std::out_of_range& e) {
4667       {
4668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (std::exception& e) {
4671       {
4672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (...) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4677       };
4678     }
4679   }
4680   jresult = result;
4681   return jresult;
4682 }
4683
4684
4685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4686   float jresult ;
4687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4688   unsigned int arg2 ;
4689   float *result = 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   arg2 = (unsigned int)jarg2;
4693   {
4694     try {
4695       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (...) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4707       };
4708     }
4709   }
4710   jresult = *result;
4711   return jresult;
4712 }
4713
4714
4715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4716   float jresult ;
4717   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4718   float result;
4719
4720   arg1 = (Dali::Vector2 *)jarg1;
4721   {
4722     try {
4723       result = (float)((Dali::Vector2 const *)arg1)->Length();
4724     } catch (std::out_of_range& e) {
4725       {
4726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4727       };
4728     } catch (std::exception& e) {
4729       {
4730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4731       };
4732     } catch (...) {
4733       {
4734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4735       };
4736     }
4737   }
4738   jresult = result;
4739   return jresult;
4740 }
4741
4742
4743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4744   float jresult ;
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float result;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   {
4750     try {
4751       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4752     } catch (std::out_of_range& e) {
4753       {
4754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4755       };
4756     } catch (std::exception& e) {
4757       {
4758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4759       };
4760     } catch (...) {
4761       {
4762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4763       };
4764     }
4765   }
4766   jresult = result;
4767   return jresult;
4768 }
4769
4770
4771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4772   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   {
4776     try {
4777       (arg1)->Normalize();
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4785       };
4786     } catch (...) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4789       };
4790     }
4791   }
4792 }
4793
4794
4795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4797   Dali::Vector2 *arg2 = 0 ;
4798   Dali::Vector2 *arg3 = 0 ;
4799
4800   arg1 = (Dali::Vector2 *)jarg1;
4801   arg2 = (Dali::Vector2 *)jarg2;
4802   if (!arg2) {
4803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4804     return ;
4805   }
4806   arg3 = (Dali::Vector2 *)jarg3;
4807   if (!arg3) {
4808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4809     return ;
4810   }
4811   {
4812     try {
4813       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4814     } catch (std::out_of_range& e) {
4815       {
4816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4817       };
4818     } catch (std::exception& e) {
4819       {
4820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4821       };
4822     } catch (...) {
4823       {
4824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4825       };
4826     }
4827   }
4828 }
4829
4830
4831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4832   void * jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   float *result = 0 ;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   {
4838     try {
4839       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4840     } catch (std::out_of_range& e) {
4841       {
4842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4843       };
4844     } catch (std::exception& e) {
4845       {
4846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4847       };
4848     } catch (...) {
4849       {
4850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4851       };
4852     }
4853   }
4854   jresult = (void *)result;
4855   return jresult;
4856 }
4857
4858
4859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4860   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4861   float arg2 ;
4862
4863   arg1 = (Dali::Vector2 *)jarg1;
4864   arg2 = (float)jarg2;
4865   if (arg1) (arg1)->x = arg2;
4866 }
4867
4868
4869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4870   float jresult ;
4871   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4872   float result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   result = (float) ((arg1)->x);
4876   jresult = result;
4877   return jresult;
4878 }
4879
4880
4881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4882   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4883   float arg2 ;
4884
4885   arg1 = (Dali::Vector2 *)jarg1;
4886   arg2 = (float)jarg2;
4887   if (arg1) (arg1)->width = arg2;
4888 }
4889
4890
4891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4892   float jresult ;
4893   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4894   float result;
4895
4896   arg1 = (Dali::Vector2 *)jarg1;
4897   result = (float) ((arg1)->width);
4898   jresult = result;
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4904   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4905   float arg2 ;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (float)jarg2;
4909   if (arg1) (arg1)->y = arg2;
4910 }
4911
4912
4913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4914   float jresult ;
4915   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4916   float result;
4917
4918   arg1 = (Dali::Vector2 *)jarg1;
4919   result = (float) ((arg1)->y);
4920   jresult = result;
4921   return jresult;
4922 }
4923
4924
4925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4926   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4927   float arg2 ;
4928
4929   arg1 = (Dali::Vector2 *)jarg1;
4930   arg2 = (float)jarg2;
4931   if (arg1) (arg1)->height = arg2;
4932 }
4933
4934
4935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4936   float jresult ;
4937   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4938   float result;
4939
4940   arg1 = (Dali::Vector2 *)jarg1;
4941   result = (float) ((arg1)->height);
4942   jresult = result;
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4948   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   {
4952     try {
4953       delete arg1;
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4961       };
4962     } catch (...) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4965       };
4966     }
4967   }
4968 }
4969
4970
4971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4972   void * jresult ;
4973   Dali::Vector2 *arg1 = 0 ;
4974   Dali::Vector2 *arg2 = 0 ;
4975   Dali::Vector2 result;
4976
4977   arg1 = (Dali::Vector2 *)jarg1;
4978   if (!arg1) {
4979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4980     return 0;
4981   }
4982   arg2 = (Dali::Vector2 *)jarg2;
4983   if (!arg2) {
4984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4985     return 0;
4986   }
4987   {
4988     try {
4989       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4990     } catch (std::out_of_range& e) {
4991       {
4992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (std::exception& e) {
4995       {
4996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5010   void * jresult ;
5011   Dali::Vector2 *arg1 = 0 ;
5012   Dali::Vector2 *arg2 = 0 ;
5013   Dali::Vector2 result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   if (!arg1) {
5017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5018     return 0;
5019   }
5020   arg2 = (Dali::Vector2 *)jarg2;
5021   if (!arg2) {
5022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5023     return 0;
5024   }
5025   {
5026     try {
5027       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5028     } catch (std::out_of_range& e) {
5029       {
5030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5031       };
5032     } catch (std::exception& e) {
5033       {
5034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (...) {
5037       {
5038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5039       };
5040     }
5041   }
5042   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5043   return jresult;
5044 }
5045
5046
5047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5048   void * jresult ;
5049   Dali::Vector2 *arg1 = 0 ;
5050   float *arg2 = 0 ;
5051   float *arg3 = 0 ;
5052   float temp2 ;
5053   float temp3 ;
5054   Dali::Vector2 result;
5055
5056   arg1 = (Dali::Vector2 *)jarg1;
5057   if (!arg1) {
5058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5059     return 0;
5060   }
5061   temp2 = (float)jarg2;
5062   arg2 = &temp2;
5063   temp3 = (float)jarg3;
5064   arg3 = &temp3;
5065   {
5066     try {
5067       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5068     } catch (std::out_of_range& e) {
5069       {
5070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (std::exception& e) {
5073       {
5074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (...) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5079       };
5080     }
5081   }
5082   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5083   return jresult;
5084 }
5085
5086
5087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5088   void * jresult ;
5089   Dali::Vector3 *result = 0 ;
5090
5091   {
5092     try {
5093       result = (Dali::Vector3 *)new Dali::Vector3();
5094     } catch (std::out_of_range& e) {
5095       {
5096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5097       };
5098     } catch (std::exception& e) {
5099       {
5100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5101       };
5102     } catch (...) {
5103       {
5104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5105       };
5106     }
5107   }
5108   jresult = (void *)result;
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5114   void * jresult ;
5115   float arg1 ;
5116   float arg2 ;
5117   float arg3 ;
5118   Dali::Vector3 *result = 0 ;
5119
5120   arg1 = (float)jarg1;
5121   arg2 = (float)jarg2;
5122   arg3 = (float)jarg3;
5123   {
5124     try {
5125       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5126     } catch (std::out_of_range& e) {
5127       {
5128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5129       };
5130     } catch (std::exception& e) {
5131       {
5132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5133       };
5134     } catch (...) {
5135       {
5136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5137       };
5138     }
5139   }
5140   jresult = (void *)result;
5141   return jresult;
5142 }
5143
5144
5145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5146   void * jresult ;
5147   float *arg1 = (float *) 0 ;
5148   Dali::Vector3 *result = 0 ;
5149
5150   arg1 = jarg1;
5151   {
5152     try {
5153       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5154     } catch (std::out_of_range& e) {
5155       {
5156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5157       };
5158     } catch (std::exception& e) {
5159       {
5160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5161       };
5162     } catch (...) {
5163       {
5164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5165       };
5166     }
5167   }
5168   jresult = (void *)result;
5169
5170
5171   return jresult;
5172 }
5173
5174
5175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5176   void * jresult ;
5177   Dali::Vector2 *arg1 = 0 ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   arg1 = (Dali::Vector2 *)jarg1;
5181   if (!arg1) {
5182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5183     return 0;
5184   }
5185   {
5186     try {
5187       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5188     } catch (std::out_of_range& e) {
5189       {
5190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5191       };
5192     } catch (std::exception& e) {
5193       {
5194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5195       };
5196     } catch (...) {
5197       {
5198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5199       };
5200     }
5201   }
5202   jresult = (void *)result;
5203   return jresult;
5204 }
5205
5206
5207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5208   void * jresult ;
5209   Dali::Vector4 *arg1 = 0 ;
5210   Dali::Vector3 *result = 0 ;
5211
5212   arg1 = (Dali::Vector4 *)jarg1;
5213   if (!arg1) {
5214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5215     return 0;
5216   }
5217   {
5218     try {
5219       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5220     } catch (std::out_of_range& e) {
5221       {
5222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5223       };
5224     } catch (std::exception& e) {
5225       {
5226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5227       };
5228     } catch (...) {
5229       {
5230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5231       };
5232     }
5233   }
5234   jresult = (void *)result;
5235   return jresult;
5236 }
5237
5238
5239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5240   void * jresult ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5244   jresult = (void *)result;
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5250   void * jresult ;
5251   Dali::Vector3 *result = 0 ;
5252
5253   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5254   jresult = (void *)result;
5255   return jresult;
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5260   void * jresult ;
5261   Dali::Vector3 *result = 0 ;
5262
5263   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5264   jresult = (void *)result;
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5270   void * jresult ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5274   jresult = (void *)result;
5275   return jresult;
5276 }
5277
5278
5279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5280   void * jresult ;
5281   Dali::Vector3 *result = 0 ;
5282
5283   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5284   jresult = (void *)result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5290   void * jresult ;
5291   Dali::Vector3 *result = 0 ;
5292
5293   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5294   jresult = (void *)result;
5295   return jresult;
5296 }
5297
5298
5299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5300   void * jresult ;
5301   Dali::Vector3 *result = 0 ;
5302
5303   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5304   jresult = (void *)result;
5305   return jresult;
5306 }
5307
5308
5309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5310   void * jresult ;
5311   Dali::Vector3 *result = 0 ;
5312
5313   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5314   jresult = (void *)result;
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5320   void * jresult ;
5321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5322   float *arg2 = (float *) 0 ;
5323   Dali::Vector3 *result = 0 ;
5324
5325   arg1 = (Dali::Vector3 *)jarg1;
5326   arg2 = jarg2;
5327   {
5328     try {
5329       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5330     } catch (std::out_of_range& e) {
5331       {
5332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5333       };
5334     } catch (std::exception& e) {
5335       {
5336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (...) {
5339       {
5340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5341       };
5342     }
5343   }
5344   jresult = (void *)result;
5345
5346
5347   return jresult;
5348 }
5349
5350
5351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5352   void * jresult ;
5353   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5354   Dali::Vector2 *arg2 = 0 ;
5355   Dali::Vector3 *result = 0 ;
5356
5357   arg1 = (Dali::Vector3 *)jarg1;
5358   arg2 = (Dali::Vector2 *)jarg2;
5359   if (!arg2) {
5360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5361     return 0;
5362   }
5363   {
5364     try {
5365       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5366     } catch (std::out_of_range& e) {
5367       {
5368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5369       };
5370     } catch (std::exception& e) {
5371       {
5372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5373       };
5374     } catch (...) {
5375       {
5376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5377       };
5378     }
5379   }
5380   jresult = (void *)result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5386   void * jresult ;
5387   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5388   Dali::Vector4 *arg2 = 0 ;
5389   Dali::Vector3 *result = 0 ;
5390
5391   arg1 = (Dali::Vector3 *)jarg1;
5392   arg2 = (Dali::Vector4 *)jarg2;
5393   if (!arg2) {
5394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5395     return 0;
5396   }
5397   {
5398     try {
5399       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5400     } catch (std::out_of_range& e) {
5401       {
5402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5403       };
5404     } catch (std::exception& e) {
5405       {
5406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5407       };
5408     } catch (...) {
5409       {
5410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5411       };
5412     }
5413   }
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5420   void * jresult ;
5421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5422   Dali::Vector3 *arg2 = 0 ;
5423   Dali::Vector3 result;
5424
5425   arg1 = (Dali::Vector3 *)jarg1;
5426   arg2 = (Dali::Vector3 *)jarg2;
5427   if (!arg2) {
5428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5429     return 0;
5430   }
5431   {
5432     try {
5433       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5456   Dali::Vector3 *arg2 = 0 ;
5457   Dali::Vector3 *result = 0 ;
5458
5459   arg1 = (Dali::Vector3 *)jarg1;
5460   arg2 = (Dali::Vector3 *)jarg2;
5461   if (!arg2) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5463     return 0;
5464   }
5465   {
5466     try {
5467       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5468     } catch (std::out_of_range& e) {
5469       {
5470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (std::exception& e) {
5473       {
5474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482   jresult = (void *)result;
5483   return jresult;
5484 }
5485
5486
5487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5488   void * jresult ;
5489   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5490   Dali::Vector3 *arg2 = 0 ;
5491   Dali::Vector3 result;
5492
5493   arg1 = (Dali::Vector3 *)jarg1;
5494   arg2 = (Dali::Vector3 *)jarg2;
5495   if (!arg2) {
5496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5497     return 0;
5498   }
5499   {
5500     try {
5501       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5502     } catch (std::out_of_range& e) {
5503       {
5504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5505       };
5506     } catch (std::exception& e) {
5507       {
5508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5509       };
5510     } catch (...) {
5511       {
5512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5513       };
5514     }
5515   }
5516   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5517   return jresult;
5518 }
5519
5520
5521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5522   void * jresult ;
5523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5524   Dali::Vector3 *arg2 = 0 ;
5525   Dali::Vector3 *result = 0 ;
5526
5527   arg1 = (Dali::Vector3 *)jarg1;
5528   arg2 = (Dali::Vector3 *)jarg2;
5529   if (!arg2) {
5530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5531     return 0;
5532   }
5533   {
5534     try {
5535       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5536     } catch (std::out_of_range& e) {
5537       {
5538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (std::exception& e) {
5541       {
5542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5543       };
5544     } catch (...) {
5545       {
5546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5547       };
5548     }
5549   }
5550   jresult = (void *)result;
5551   return jresult;
5552 }
5553
5554
5555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5556   void * jresult ;
5557   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5558   Dali::Vector3 *arg2 = 0 ;
5559   Dali::Vector3 result;
5560
5561   arg1 = (Dali::Vector3 *)jarg1;
5562   arg2 = (Dali::Vector3 *)jarg2;
5563   if (!arg2) {
5564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5565     return 0;
5566   }
5567   {
5568     try {
5569       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (...) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5581       };
5582     }
5583   }
5584   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5590   void * jresult ;
5591   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5592   float arg2 ;
5593   Dali::Vector3 result;
5594
5595   arg1 = (Dali::Vector3 *)jarg1;
5596   arg2 = (float)jarg2;
5597   {
5598     try {
5599       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5615   return jresult;
5616 }
5617
5618
5619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5620   void * jresult ;
5621   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5622   Dali::Vector3 *arg2 = 0 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (Dali::Vector3 *)jarg1;
5626   arg2 = (Dali::Vector3 *)jarg2;
5627   if (!arg2) {
5628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5629     return 0;
5630   }
5631   {
5632     try {
5633       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5634     } catch (std::out_of_range& e) {
5635       {
5636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (std::exception& e) {
5639       {
5640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5654   void * jresult ;
5655   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5656   float arg2 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = (Dali::Vector3 *)jarg1;
5660   arg2 = (float)jarg2;
5661   {
5662     try {
5663       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (...) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5675       };
5676     }
5677   }
5678   jresult = (void *)result;
5679   return jresult;
5680 }
5681
5682
5683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5684   void * jresult ;
5685   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5686   Dali::Quaternion *arg2 = 0 ;
5687   Dali::Vector3 *result = 0 ;
5688
5689   arg1 = (Dali::Vector3 *)jarg1;
5690   arg2 = (Dali::Quaternion *)jarg2;
5691   if (!arg2) {
5692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5693     return 0;
5694   }
5695   {
5696     try {
5697       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5698     } catch (std::out_of_range& e) {
5699       {
5700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (std::exception& e) {
5703       {
5704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (...) {
5707       {
5708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5709       };
5710     }
5711   }
5712   jresult = (void *)result;
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5718   void * jresult ;
5719   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5720   Dali::Vector3 *arg2 = 0 ;
5721   Dali::Vector3 result;
5722
5723   arg1 = (Dali::Vector3 *)jarg1;
5724   arg2 = (Dali::Vector3 *)jarg2;
5725   if (!arg2) {
5726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5727     return 0;
5728   }
5729   {
5730     try {
5731       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5732     } catch (std::out_of_range& e) {
5733       {
5734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5735       };
5736     } catch (std::exception& e) {
5737       {
5738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5739       };
5740     } catch (...) {
5741       {
5742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5743       };
5744     }
5745   }
5746   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5747   return jresult;
5748 }
5749
5750
5751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5752   void * jresult ;
5753   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5754   float arg2 ;
5755   Dali::Vector3 result;
5756
5757   arg1 = (Dali::Vector3 *)jarg1;
5758   arg2 = (float)jarg2;
5759   {
5760     try {
5761       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5762     } catch (std::out_of_range& e) {
5763       {
5764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5765       };
5766     } catch (std::exception& e) {
5767       {
5768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5769       };
5770     } catch (...) {
5771       {
5772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5773       };
5774     }
5775   }
5776   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5782   void * jresult ;
5783   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5784   Dali::Vector3 *arg2 = 0 ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   arg1 = (Dali::Vector3 *)jarg1;
5788   arg2 = (Dali::Vector3 *)jarg2;
5789   if (!arg2) {
5790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5791     return 0;
5792   }
5793   {
5794     try {
5795       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5796     } catch (std::out_of_range& e) {
5797       {
5798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5799       };
5800     } catch (std::exception& e) {
5801       {
5802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5803       };
5804     } catch (...) {
5805       {
5806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5807       };
5808     }
5809   }
5810   jresult = (void *)result;
5811   return jresult;
5812 }
5813
5814
5815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5816   void * jresult ;
5817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5818   float arg2 ;
5819   Dali::Vector3 *result = 0 ;
5820
5821   arg1 = (Dali::Vector3 *)jarg1;
5822   arg2 = (float)jarg2;
5823   {
5824     try {
5825       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5826     } catch (std::out_of_range& e) {
5827       {
5828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5829       };
5830     } catch (std::exception& e) {
5831       {
5832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5833       };
5834     } catch (...) {
5835       {
5836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5837       };
5838     }
5839   }
5840   jresult = (void *)result;
5841   return jresult;
5842 }
5843
5844
5845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5846   void * jresult ;
5847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5848   Dali::Vector3 result;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   {
5852     try {
5853       result = ((Dali::Vector3 const *)arg1)->operator -();
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (...) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5865       };
5866     }
5867   }
5868   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5869   return jresult;
5870 }
5871
5872
5873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5874   unsigned int jresult ;
5875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5876   Dali::Vector3 *arg2 = 0 ;
5877   bool result;
5878
5879   arg1 = (Dali::Vector3 *)jarg1;
5880   arg2 = (Dali::Vector3 *)jarg2;
5881   if (!arg2) {
5882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5883     return 0;
5884   }
5885   {
5886     try {
5887       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5888     } catch (std::out_of_range& e) {
5889       {
5890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (std::exception& e) {
5893       {
5894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (...) {
5897       {
5898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5899       };
5900     }
5901   }
5902   jresult = result;
5903   return jresult;
5904 }
5905
5906
5907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5908   unsigned int jresult ;
5909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5910   Dali::Vector3 *arg2 = 0 ;
5911   bool result;
5912
5913   arg1 = (Dali::Vector3 *)jarg1;
5914   arg2 = (Dali::Vector3 *)jarg2;
5915   if (!arg2) {
5916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5917     return 0;
5918   }
5919   {
5920     try {
5921       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5922     } catch (std::out_of_range& e) {
5923       {
5924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5925       };
5926     } catch (std::exception& e) {
5927       {
5928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5929       };
5930     } catch (...) {
5931       {
5932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5933       };
5934     }
5935   }
5936   jresult = result;
5937   return jresult;
5938 }
5939
5940
5941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5942   float jresult ;
5943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5944   unsigned int arg2 ;
5945   float *result = 0 ;
5946
5947   arg1 = (Dali::Vector3 *)jarg1;
5948   arg2 = (unsigned int)jarg2;
5949   {
5950     try {
5951       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5952     } catch (std::out_of_range& e) {
5953       {
5954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (std::exception& e) {
5957       {
5958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5959       };
5960     } catch (...) {
5961       {
5962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5963       };
5964     }
5965   }
5966   jresult = *result;
5967   return jresult;
5968 }
5969
5970
5971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5972   float jresult ;
5973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5974   Dali::Vector3 *arg2 = 0 ;
5975   float result;
5976
5977   arg1 = (Dali::Vector3 *)jarg1;
5978   arg2 = (Dali::Vector3 *)jarg2;
5979   if (!arg2) {
5980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5981     return 0;
5982   }
5983   {
5984     try {
5985       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5986     } catch (std::out_of_range& e) {
5987       {
5988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (std::exception& e) {
5991       {
5992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5993       };
5994     } catch (...) {
5995       {
5996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5997       };
5998     }
5999   }
6000   jresult = result;
6001   return jresult;
6002 }
6003
6004
6005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6006   void * jresult ;
6007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6008   Dali::Vector3 *arg2 = 0 ;
6009   Dali::Vector3 result;
6010
6011   arg1 = (Dali::Vector3 *)jarg1;
6012   arg2 = (Dali::Vector3 *)jarg2;
6013   if (!arg2) {
6014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6015     return 0;
6016   }
6017   {
6018     try {
6019       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (...) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6031       };
6032     }
6033   }
6034   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6040   float jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   float result;
6043
6044   arg1 = (Dali::Vector3 *)jarg1;
6045   {
6046     try {
6047       result = (float)((Dali::Vector3 const *)arg1)->Length();
6048     } catch (std::out_of_range& e) {
6049       {
6050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (std::exception& e) {
6053       {
6054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (...) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6059       };
6060     }
6061   }
6062   jresult = result;
6063   return jresult;
6064 }
6065
6066
6067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6068   float jresult ;
6069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6070   float result;
6071
6072   arg1 = (Dali::Vector3 *)jarg1;
6073   {
6074     try {
6075       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6076     } catch (std::out_of_range& e) {
6077       {
6078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6079       };
6080     } catch (std::exception& e) {
6081       {
6082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (...) {
6085       {
6086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6087       };
6088     }
6089   }
6090   jresult = result;
6091   return jresult;
6092 }
6093
6094
6095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6097
6098   arg1 = (Dali::Vector3 *)jarg1;
6099   {
6100     try {
6101       (arg1)->Normalize();
6102     } catch (std::out_of_range& e) {
6103       {
6104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6105       };
6106     } catch (std::exception& e) {
6107       {
6108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6113       };
6114     }
6115   }
6116 }
6117
6118
6119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6120   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6121   Dali::Vector3 *arg2 = 0 ;
6122   Dali::Vector3 *arg3 = 0 ;
6123
6124   arg1 = (Dali::Vector3 *)jarg1;
6125   arg2 = (Dali::Vector3 *)jarg2;
6126   if (!arg2) {
6127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6128     return ;
6129   }
6130   arg3 = (Dali::Vector3 *)jarg3;
6131   if (!arg3) {
6132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6133     return ;
6134   }
6135   {
6136     try {
6137       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6149       };
6150     }
6151   }
6152 }
6153
6154
6155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6156   void * jresult ;
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float *result = 0 ;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   {
6162     try {
6163       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (...) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6175       };
6176     }
6177   }
6178   jresult = (void *)result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   Dali::Vector2 *result = 0 ;
6187
6188   arg1 = (Dali::Vector3 *)jarg1;
6189   {
6190     try {
6191       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6192     } catch (std::out_of_range& e) {
6193       {
6194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6195       };
6196     } catch (std::exception& e) {
6197       {
6198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (...) {
6201       {
6202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6203       };
6204     }
6205   }
6206   jresult = (void *)result;
6207   return jresult;
6208 }
6209
6210
6211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6212   void * jresult ;
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   Dali::Vector2 *result = 0 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   {
6218     try {
6219       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6220     } catch (std::out_of_range& e) {
6221       {
6222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6223       };
6224     } catch (std::exception& e) {
6225       {
6226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6227       };
6228     } catch (...) {
6229       {
6230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6231       };
6232     }
6233   }
6234   jresult = (void *)result;
6235   return jresult;
6236 }
6237
6238
6239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6240   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6241   float arg2 ;
6242
6243   arg1 = (Dali::Vector3 *)jarg1;
6244   arg2 = (float)jarg2;
6245   if (arg1) (arg1)->x = arg2;
6246 }
6247
6248
6249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6250   float jresult ;
6251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6252   float result;
6253
6254   arg1 = (Dali::Vector3 *)jarg1;
6255   result = (float) ((arg1)->x);
6256   jresult = result;
6257   return jresult;
6258 }
6259
6260
6261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6262   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6263   float arg2 ;
6264
6265   arg1 = (Dali::Vector3 *)jarg1;
6266   arg2 = (float)jarg2;
6267   if (arg1) (arg1)->width = arg2;
6268 }
6269
6270
6271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6272   float jresult ;
6273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6274   float result;
6275
6276   arg1 = (Dali::Vector3 *)jarg1;
6277   result = (float) ((arg1)->width);
6278   jresult = result;
6279   return jresult;
6280 }
6281
6282
6283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6284   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6285   float arg2 ;
6286
6287   arg1 = (Dali::Vector3 *)jarg1;
6288   arg2 = (float)jarg2;
6289   if (arg1) (arg1)->r = arg2;
6290 }
6291
6292
6293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6294   float jresult ;
6295   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6296   float result;
6297
6298   arg1 = (Dali::Vector3 *)jarg1;
6299   result = (float) ((arg1)->r);
6300   jresult = result;
6301   return jresult;
6302 }
6303
6304
6305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   float arg2 ;
6308
6309   arg1 = (Dali::Vector3 *)jarg1;
6310   arg2 = (float)jarg2;
6311   if (arg1) (arg1)->y = arg2;
6312 }
6313
6314
6315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6316   float jresult ;
6317   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6318   float result;
6319
6320   arg1 = (Dali::Vector3 *)jarg1;
6321   result = (float) ((arg1)->y);
6322   jresult = result;
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6328   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6329   float arg2 ;
6330
6331   arg1 = (Dali::Vector3 *)jarg1;
6332   arg2 = (float)jarg2;
6333   if (arg1) (arg1)->height = arg2;
6334 }
6335
6336
6337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6338   float jresult ;
6339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6340   float result;
6341
6342   arg1 = (Dali::Vector3 *)jarg1;
6343   result = (float) ((arg1)->height);
6344   jresult = result;
6345   return jresult;
6346 }
6347
6348
6349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6351   float arg2 ;
6352
6353   arg1 = (Dali::Vector3 *)jarg1;
6354   arg2 = (float)jarg2;
6355   if (arg1) (arg1)->g = arg2;
6356 }
6357
6358
6359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6360   float jresult ;
6361   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6362   float result;
6363
6364   arg1 = (Dali::Vector3 *)jarg1;
6365   result = (float) ((arg1)->g);
6366   jresult = result;
6367   return jresult;
6368 }
6369
6370
6371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   float arg2 ;
6374
6375   arg1 = (Dali::Vector3 *)jarg1;
6376   arg2 = (float)jarg2;
6377   if (arg1) (arg1)->z = arg2;
6378 }
6379
6380
6381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6382   float jresult ;
6383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6384   float result;
6385
6386   arg1 = (Dali::Vector3 *)jarg1;
6387   result = (float) ((arg1)->z);
6388   jresult = result;
6389   return jresult;
6390 }
6391
6392
6393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6394   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6395   float arg2 ;
6396
6397   arg1 = (Dali::Vector3 *)jarg1;
6398   arg2 = (float)jarg2;
6399   if (arg1) (arg1)->depth = arg2;
6400 }
6401
6402
6403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6404   float jresult ;
6405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6406   float result;
6407
6408   arg1 = (Dali::Vector3 *)jarg1;
6409   result = (float) ((arg1)->depth);
6410   jresult = result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418
6419   arg1 = (Dali::Vector3 *)jarg1;
6420   arg2 = (float)jarg2;
6421   if (arg1) (arg1)->b = arg2;
6422 }
6423
6424
6425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6426   float jresult ;
6427   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6428   float result;
6429
6430   arg1 = (Dali::Vector3 *)jarg1;
6431   result = (float) ((arg1)->b);
6432   jresult = result;
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439
6440   arg1 = (Dali::Vector3 *)jarg1;
6441   {
6442     try {
6443       delete arg1;
6444     } catch (std::out_of_range& e) {
6445       {
6446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6447       };
6448     } catch (std::exception& e) {
6449       {
6450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6451       };
6452     } catch (...) {
6453       {
6454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6455       };
6456     }
6457   }
6458 }
6459
6460
6461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6462   void * jresult ;
6463   Dali::Vector3 *arg1 = 0 ;
6464   Dali::Vector3 *arg2 = 0 ;
6465   Dali::Vector3 result;
6466
6467   arg1 = (Dali::Vector3 *)jarg1;
6468   if (!arg1) {
6469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6470     return 0;
6471   }
6472   arg2 = (Dali::Vector3 *)jarg2;
6473   if (!arg2) {
6474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6475     return 0;
6476   }
6477   {
6478     try {
6479       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6480     } catch (std::out_of_range& e) {
6481       {
6482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (std::exception& e) {
6485       {
6486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (...) {
6489       {
6490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6491       };
6492     }
6493   }
6494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6495   return jresult;
6496 }
6497
6498
6499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6500   void * jresult ;
6501   Dali::Vector3 *arg1 = 0 ;
6502   Dali::Vector3 *arg2 = 0 ;
6503   Dali::Vector3 result;
6504
6505   arg1 = (Dali::Vector3 *)jarg1;
6506   if (!arg1) {
6507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6508     return 0;
6509   }
6510   arg2 = (Dali::Vector3 *)jarg2;
6511   if (!arg2) {
6512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6513     return 0;
6514   }
6515   {
6516     try {
6517       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6518     } catch (std::out_of_range& e) {
6519       {
6520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6521       };
6522     } catch (std::exception& e) {
6523       {
6524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6525       };
6526     } catch (...) {
6527       {
6528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6529       };
6530     }
6531   }
6532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6538   void * jresult ;
6539   Dali::Vector3 *arg1 = 0 ;
6540   float *arg2 = 0 ;
6541   float *arg3 = 0 ;
6542   float temp2 ;
6543   float temp3 ;
6544   Dali::Vector3 result;
6545
6546   arg1 = (Dali::Vector3 *)jarg1;
6547   if (!arg1) {
6548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6549     return 0;
6550   }
6551   temp2 = (float)jarg2;
6552   arg2 = &temp2;
6553   temp3 = (float)jarg3;
6554   arg3 = &temp3;
6555   {
6556     try {
6557       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6558     } catch (std::out_of_range& e) {
6559       {
6560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6561       };
6562     } catch (std::exception& e) {
6563       {
6564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (...) {
6567       {
6568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6569       };
6570     }
6571   }
6572   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6573   return jresult;
6574 }
6575
6576
6577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6578   void * jresult ;
6579   Dali::Vector4 *result = 0 ;
6580
6581   {
6582     try {
6583       result = (Dali::Vector4 *)new Dali::Vector4();
6584     } catch (std::out_of_range& e) {
6585       {
6586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (std::exception& e) {
6589       {
6590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598   jresult = (void *)result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6604   void * jresult ;
6605   float arg1 ;
6606   float arg2 ;
6607   float arg3 ;
6608   float arg4 ;
6609   Dali::Vector4 *result = 0 ;
6610
6611   arg1 = (float)jarg1;
6612   arg2 = (float)jarg2;
6613   arg3 = (float)jarg3;
6614   arg4 = (float)jarg4;
6615   {
6616     try {
6617       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6618     } catch (std::out_of_range& e) {
6619       {
6620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6621       };
6622     } catch (std::exception& e) {
6623       {
6624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (...) {
6627       {
6628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6629       };
6630     }
6631   }
6632   jresult = (void *)result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6638   void * jresult ;
6639   float *arg1 = (float *) 0 ;
6640   Dali::Vector4 *result = 0 ;
6641
6642   arg1 = jarg1;
6643   {
6644     try {
6645       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (...) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6657       };
6658     }
6659   }
6660   jresult = (void *)result;
6661
6662
6663   return jresult;
6664 }
6665
6666
6667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6668   void * jresult ;
6669   Dali::Vector2 *arg1 = 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector2 *)jarg1;
6673   if (!arg1) {
6674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6675     return 0;
6676   }
6677   {
6678     try {
6679       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (...) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6691       };
6692     }
6693   }
6694   jresult = (void *)result;
6695   return jresult;
6696 }
6697
6698
6699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6700   void * jresult ;
6701   Dali::Vector3 *arg1 = 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector3 *)jarg1;
6705   if (!arg1) {
6706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6707     return 0;
6708   }
6709   {
6710     try {
6711       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (...) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6723       };
6724     }
6725   }
6726   jresult = (void *)result;
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6732   void * jresult ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6742   void * jresult ;
6743   Dali::Vector4 *result = 0 ;
6744
6745   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6752   void * jresult ;
6753   Dali::Vector4 *result = 0 ;
6754
6755   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6762   void * jresult ;
6763   Dali::Vector4 *result = 0 ;
6764
6765   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6766   jresult = (void *)result;
6767   return jresult;
6768 }
6769
6770
6771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6772   void * jresult ;
6773   Dali::Vector4 *result = 0 ;
6774
6775   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6776   jresult = (void *)result;
6777   return jresult;
6778 }
6779
6780
6781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6782   void * jresult ;
6783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6784   float *arg2 = (float *) 0 ;
6785   Dali::Vector4 *result = 0 ;
6786
6787   arg1 = (Dali::Vector4 *)jarg1;
6788   arg2 = jarg2;
6789   {
6790     try {
6791       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6792     } catch (std::out_of_range& e) {
6793       {
6794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6795       };
6796     } catch (std::exception& e) {
6797       {
6798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6803       };
6804     }
6805   }
6806   jresult = (void *)result;
6807
6808
6809   return jresult;
6810 }
6811
6812
6813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6814   void * jresult ;
6815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6816   Dali::Vector2 *arg2 = 0 ;
6817   Dali::Vector4 *result = 0 ;
6818
6819   arg1 = (Dali::Vector4 *)jarg1;
6820   arg2 = (Dali::Vector2 *)jarg2;
6821   if (!arg2) {
6822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6823     return 0;
6824   }
6825   {
6826     try {
6827       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6828     } catch (std::out_of_range& e) {
6829       {
6830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (std::exception& e) {
6833       {
6834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6835       };
6836     } catch (...) {
6837       {
6838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6839       };
6840     }
6841   }
6842   jresult = (void *)result;
6843   return jresult;
6844 }
6845
6846
6847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6848   void * jresult ;
6849   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6850   Dali::Vector3 *arg2 = 0 ;
6851   Dali::Vector4 *result = 0 ;
6852
6853   arg1 = (Dali::Vector4 *)jarg1;
6854   arg2 = (Dali::Vector3 *)jarg2;
6855   if (!arg2) {
6856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6857     return 0;
6858   }
6859   {
6860     try {
6861       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6862     } catch (std::out_of_range& e) {
6863       {
6864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6865       };
6866     } catch (std::exception& e) {
6867       {
6868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6869       };
6870     } catch (...) {
6871       {
6872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6873       };
6874     }
6875   }
6876   jresult = (void *)result;
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6882   void * jresult ;
6883   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6884   Dali::Vector4 *arg2 = 0 ;
6885   Dali::Vector4 result;
6886
6887   arg1 = (Dali::Vector4 *)jarg1;
6888   arg2 = (Dali::Vector4 *)jarg2;
6889   if (!arg2) {
6890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6891     return 0;
6892   }
6893   {
6894     try {
6895       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6896     } catch (std::out_of_range& e) {
6897       {
6898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (std::exception& e) {
6901       {
6902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6911   return jresult;
6912 }
6913
6914
6915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6916   void * jresult ;
6917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6918   Dali::Vector4 *arg2 = 0 ;
6919   Dali::Vector4 *result = 0 ;
6920
6921   arg1 = (Dali::Vector4 *)jarg1;
6922   arg2 = (Dali::Vector4 *)jarg2;
6923   if (!arg2) {
6924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6925     return 0;
6926   }
6927   {
6928     try {
6929       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6930     } catch (std::out_of_range& e) {
6931       {
6932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6933       };
6934     } catch (std::exception& e) {
6935       {
6936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6937       };
6938     } catch (...) {
6939       {
6940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6941       };
6942     }
6943   }
6944   jresult = (void *)result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6950   void * jresult ;
6951   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6952   Dali::Vector4 *arg2 = 0 ;
6953   Dali::Vector4 result;
6954
6955   arg1 = (Dali::Vector4 *)jarg1;
6956   arg2 = (Dali::Vector4 *)jarg2;
6957   if (!arg2) {
6958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6959     return 0;
6960   }
6961   {
6962     try {
6963       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6964     } catch (std::out_of_range& e) {
6965       {
6966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6967       };
6968     } catch (std::exception& e) {
6969       {
6970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6971       };
6972     } catch (...) {
6973       {
6974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6975       };
6976     }
6977   }
6978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6979   return jresult;
6980 }
6981
6982
6983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6984   void * jresult ;
6985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6986   Dali::Vector4 *arg2 = 0 ;
6987   Dali::Vector4 *result = 0 ;
6988
6989   arg1 = (Dali::Vector4 *)jarg1;
6990   arg2 = (Dali::Vector4 *)jarg2;
6991   if (!arg2) {
6992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6993     return 0;
6994   }
6995   {
6996     try {
6997       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6998     } catch (std::out_of_range& e) {
6999       {
7000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (std::exception& e) {
7003       {
7004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7005       };
7006     } catch (...) {
7007       {
7008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7009       };
7010     }
7011   }
7012   jresult = (void *)result;
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7018   void * jresult ;
7019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7020   Dali::Vector4 *arg2 = 0 ;
7021   Dali::Vector4 result;
7022
7023   arg1 = (Dali::Vector4 *)jarg1;
7024   arg2 = (Dali::Vector4 *)jarg2;
7025   if (!arg2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7027     return 0;
7028   }
7029   {
7030     try {
7031       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7032     } catch (std::out_of_range& e) {
7033       {
7034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7035       };
7036     } catch (std::exception& e) {
7037       {
7038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7039       };
7040     } catch (...) {
7041       {
7042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7043       };
7044     }
7045   }
7046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7047   return jresult;
7048 }
7049
7050
7051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7052   void * jresult ;
7053   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7054   float arg2 ;
7055   Dali::Vector4 result;
7056
7057   arg1 = (Dali::Vector4 *)jarg1;
7058   arg2 = (float)jarg2;
7059   {
7060     try {
7061       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7062     } catch (std::out_of_range& e) {
7063       {
7064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (std::exception& e) {
7067       {
7068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7069       };
7070     } catch (...) {
7071       {
7072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7073       };
7074     }
7075   }
7076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7082   void * jresult ;
7083   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7084   Dali::Vector4 *arg2 = 0 ;
7085   Dali::Vector4 *result = 0 ;
7086
7087   arg1 = (Dali::Vector4 *)jarg1;
7088   arg2 = (Dali::Vector4 *)jarg2;
7089   if (!arg2) {
7090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7091     return 0;
7092   }
7093   {
7094     try {
7095       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7096     } catch (std::out_of_range& e) {
7097       {
7098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7099       };
7100     } catch (std::exception& e) {
7101       {
7102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7103       };
7104     } catch (...) {
7105       {
7106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7107       };
7108     }
7109   }
7110   jresult = (void *)result;
7111   return jresult;
7112 }
7113
7114
7115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7116   void * jresult ;
7117   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7118   float arg2 ;
7119   Dali::Vector4 *result = 0 ;
7120
7121   arg1 = (Dali::Vector4 *)jarg1;
7122   arg2 = (float)jarg2;
7123   {
7124     try {
7125       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7126     } catch (std::out_of_range& e) {
7127       {
7128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7129       };
7130     } catch (std::exception& e) {
7131       {
7132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7133       };
7134     } catch (...) {
7135       {
7136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7137       };
7138     }
7139   }
7140   jresult = (void *)result;
7141   return jresult;
7142 }
7143
7144
7145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7146   void * jresult ;
7147   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7148   Dali::Vector4 *arg2 = 0 ;
7149   Dali::Vector4 result;
7150
7151   arg1 = (Dali::Vector4 *)jarg1;
7152   arg2 = (Dali::Vector4 *)jarg2;
7153   if (!arg2) {
7154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7155     return 0;
7156   }
7157   {
7158     try {
7159       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7160     } catch (std::out_of_range& e) {
7161       {
7162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7163       };
7164     } catch (std::exception& e) {
7165       {
7166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7167       };
7168     } catch (...) {
7169       {
7170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7171       };
7172     }
7173   }
7174   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7180   void * jresult ;
7181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7182   float arg2 ;
7183   Dali::Vector4 result;
7184
7185   arg1 = (Dali::Vector4 *)jarg1;
7186   arg2 = (float)jarg2;
7187   {
7188     try {
7189       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7190     } catch (std::out_of_range& e) {
7191       {
7192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7193       };
7194     } catch (std::exception& e) {
7195       {
7196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (...) {
7199       {
7200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7201       };
7202     }
7203   }
7204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7205   return jresult;
7206 }
7207
7208
7209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7210   void * jresult ;
7211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7212   Dali::Vector4 *arg2 = 0 ;
7213   Dali::Vector4 *result = 0 ;
7214
7215   arg1 = (Dali::Vector4 *)jarg1;
7216   arg2 = (Dali::Vector4 *)jarg2;
7217   if (!arg2) {
7218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7219     return 0;
7220   }
7221   {
7222     try {
7223       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7224     } catch (std::out_of_range& e) {
7225       {
7226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7227       };
7228     } catch (std::exception& e) {
7229       {
7230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7231       };
7232     } catch (...) {
7233       {
7234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7235       };
7236     }
7237   }
7238   jresult = (void *)result;
7239   return jresult;
7240 }
7241
7242
7243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7244   void * jresult ;
7245   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7246   float arg2 ;
7247   Dali::Vector4 *result = 0 ;
7248
7249   arg1 = (Dali::Vector4 *)jarg1;
7250   arg2 = (float)jarg2;
7251   {
7252     try {
7253       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7254     } catch (std::out_of_range& e) {
7255       {
7256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (std::exception& e) {
7259       {
7260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7261       };
7262     } catch (...) {
7263       {
7264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7265       };
7266     }
7267   }
7268   jresult = (void *)result;
7269   return jresult;
7270 }
7271
7272
7273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7274   void * jresult ;
7275   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7276   Dali::Vector4 result;
7277
7278   arg1 = (Dali::Vector4 *)jarg1;
7279   {
7280     try {
7281       result = ((Dali::Vector4 const *)arg1)->operator -();
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (...) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7293       };
7294     }
7295   }
7296   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7297   return jresult;
7298 }
7299
7300
7301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7302   unsigned int jresult ;
7303   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7304   Dali::Vector4 *arg2 = 0 ;
7305   bool result;
7306
7307   arg1 = (Dali::Vector4 *)jarg1;
7308   arg2 = (Dali::Vector4 *)jarg2;
7309   if (!arg2) {
7310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7311     return 0;
7312   }
7313   {
7314     try {
7315       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7316     } catch (std::out_of_range& e) {
7317       {
7318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (std::exception& e) {
7321       {
7322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330   jresult = result;
7331   return jresult;
7332 }
7333
7334
7335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7336   unsigned int jresult ;
7337   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7338   Dali::Vector4 *arg2 = 0 ;
7339   bool result;
7340
7341   arg1 = (Dali::Vector4 *)jarg1;
7342   arg2 = (Dali::Vector4 *)jarg2;
7343   if (!arg2) {
7344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7345     return 0;
7346   }
7347   {
7348     try {
7349       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7350     } catch (std::out_of_range& e) {
7351       {
7352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (std::exception& e) {
7355       {
7356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364   jresult = result;
7365   return jresult;
7366 }
7367
7368
7369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7370   float jresult ;
7371   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7372   unsigned int arg2 ;
7373   float *result = 0 ;
7374
7375   arg1 = (Dali::Vector4 *)jarg1;
7376   arg2 = (unsigned int)jarg2;
7377   {
7378     try {
7379       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7380     } catch (std::out_of_range& e) {
7381       {
7382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (std::exception& e) {
7385       {
7386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394   jresult = *result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7400   float jresult ;
7401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7402   Dali::Vector3 *arg2 = 0 ;
7403   float result;
7404
7405   arg1 = (Dali::Vector4 *)jarg1;
7406   arg2 = (Dali::Vector3 *)jarg2;
7407   if (!arg2) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7414     } catch (std::out_of_range& e) {
7415       {
7416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (std::exception& e) {
7419       {
7420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428   jresult = result;
7429   return jresult;
7430 }
7431
7432
7433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7434   float jresult ;
7435   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7436   Dali::Vector4 *arg2 = 0 ;
7437   float result;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   arg2 = (Dali::Vector4 *)jarg2;
7441   if (!arg2) {
7442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7443     return 0;
7444   }
7445   {
7446     try {
7447       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7448     } catch (std::out_of_range& e) {
7449       {
7450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (std::exception& e) {
7453       {
7454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7455       };
7456     } catch (...) {
7457       {
7458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7459       };
7460     }
7461   }
7462   jresult = result;
7463   return jresult;
7464 }
7465
7466
7467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7468   float jresult ;
7469   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7470   Dali::Vector4 *arg2 = 0 ;
7471   float result;
7472
7473   arg1 = (Dali::Vector4 *)jarg1;
7474   arg2 = (Dali::Vector4 *)jarg2;
7475   if (!arg2) {
7476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7477     return 0;
7478   }
7479   {
7480     try {
7481       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7482     } catch (std::out_of_range& e) {
7483       {
7484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (std::exception& e) {
7487       {
7488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7489       };
7490     } catch (...) {
7491       {
7492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7493       };
7494     }
7495   }
7496   jresult = result;
7497   return jresult;
7498 }
7499
7500
7501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7502   void * jresult ;
7503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7504   Dali::Vector4 *arg2 = 0 ;
7505   Dali::Vector4 result;
7506
7507   arg1 = (Dali::Vector4 *)jarg1;
7508   arg2 = (Dali::Vector4 *)jarg2;
7509   if (!arg2) {
7510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7511     return 0;
7512   }
7513   {
7514     try {
7515       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7516     } catch (std::out_of_range& e) {
7517       {
7518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7519       };
7520     } catch (std::exception& e) {
7521       {
7522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7527       };
7528     }
7529   }
7530   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7536   float jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   float result;
7539
7540   arg1 = (Dali::Vector4 *)jarg1;
7541   {
7542     try {
7543       result = (float)((Dali::Vector4 const *)arg1)->Length();
7544     } catch (std::out_of_range& e) {
7545       {
7546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (std::exception& e) {
7549       {
7550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (...) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7555       };
7556     }
7557   }
7558   jresult = result;
7559   return jresult;
7560 }
7561
7562
7563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7564   float jresult ;
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float result;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   {
7570     try {
7571       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7572     } catch (std::out_of_range& e) {
7573       {
7574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7575       };
7576     } catch (std::exception& e) {
7577       {
7578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (...) {
7581       {
7582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7583       };
7584     }
7585   }
7586   jresult = result;
7587   return jresult;
7588 }
7589
7590
7591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   {
7596     try {
7597       (arg1)->Normalize();
7598     } catch (std::out_of_range& e) {
7599       {
7600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7601       };
7602     } catch (std::exception& e) {
7603       {
7604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7605       };
7606     } catch (...) {
7607       {
7608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7609       };
7610     }
7611   }
7612 }
7613
7614
7615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7616   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7617   Dali::Vector4 *arg2 = 0 ;
7618   Dali::Vector4 *arg3 = 0 ;
7619
7620   arg1 = (Dali::Vector4 *)jarg1;
7621   arg2 = (Dali::Vector4 *)jarg2;
7622   if (!arg2) {
7623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7624     return ;
7625   }
7626   arg3 = (Dali::Vector4 *)jarg3;
7627   if (!arg3) {
7628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7629     return ;
7630   }
7631   {
7632     try {
7633       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7634     } catch (std::out_of_range& e) {
7635       {
7636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7637       };
7638     } catch (std::exception& e) {
7639       {
7640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7641       };
7642     } catch (...) {
7643       {
7644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7645       };
7646     }
7647   }
7648 }
7649
7650
7651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7652   void * jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   {
7658     try {
7659       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7660     } catch (std::out_of_range& e) {
7661       {
7662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7663       };
7664     } catch (std::exception& e) {
7665       {
7666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (...) {
7669       {
7670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7671       };
7672     }
7673   }
7674   jresult = (void *)result;
7675   return jresult;
7676 }
7677
7678
7679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7681   float arg2 ;
7682
7683   arg1 = (Dali::Vector4 *)jarg1;
7684   arg2 = (float)jarg2;
7685   if (arg1) (arg1)->x = arg2;
7686 }
7687
7688
7689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7690   float jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   float result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   result = (float) ((arg1)->x);
7696   jresult = result;
7697   return jresult;
7698 }
7699
7700
7701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7703   float arg2 ;
7704
7705   arg1 = (Dali::Vector4 *)jarg1;
7706   arg2 = (float)jarg2;
7707   if (arg1) (arg1)->r = arg2;
7708 }
7709
7710
7711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7712   float jresult ;
7713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7714   float result;
7715
7716   arg1 = (Dali::Vector4 *)jarg1;
7717   result = (float) ((arg1)->r);
7718   jresult = result;
7719   return jresult;
7720 }
7721
7722
7723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   float arg2 ;
7726
7727   arg1 = (Dali::Vector4 *)jarg1;
7728   arg2 = (float)jarg2;
7729   if (arg1) (arg1)->s = arg2;
7730 }
7731
7732
7733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7734   float jresult ;
7735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7736   float result;
7737
7738   arg1 = (Dali::Vector4 *)jarg1;
7739   result = (float) ((arg1)->s);
7740   jresult = result;
7741   return jresult;
7742 }
7743
7744
7745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7747   float arg2 ;
7748
7749   arg1 = (Dali::Vector4 *)jarg1;
7750   arg2 = (float)jarg2;
7751   if (arg1) (arg1)->y = arg2;
7752 }
7753
7754
7755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7756   float jresult ;
7757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7758   float result;
7759
7760   arg1 = (Dali::Vector4 *)jarg1;
7761   result = (float) ((arg1)->y);
7762   jresult = result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   float arg2 ;
7770
7771   arg1 = (Dali::Vector4 *)jarg1;
7772   arg2 = (float)jarg2;
7773   if (arg1) (arg1)->g = arg2;
7774 }
7775
7776
7777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7778   float jresult ;
7779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7780   float result;
7781
7782   arg1 = (Dali::Vector4 *)jarg1;
7783   result = (float) ((arg1)->g);
7784   jresult = result;
7785   return jresult;
7786 }
7787
7788
7789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7791   float arg2 ;
7792
7793   arg1 = (Dali::Vector4 *)jarg1;
7794   arg2 = (float)jarg2;
7795   if (arg1) (arg1)->t = arg2;
7796 }
7797
7798
7799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7800   float jresult ;
7801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7802   float result;
7803
7804   arg1 = (Dali::Vector4 *)jarg1;
7805   result = (float) ((arg1)->t);
7806   jresult = result;
7807   return jresult;
7808 }
7809
7810
7811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7813   float arg2 ;
7814
7815   arg1 = (Dali::Vector4 *)jarg1;
7816   arg2 = (float)jarg2;
7817   if (arg1) (arg1)->z = arg2;
7818 }
7819
7820
7821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7822   float jresult ;
7823   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7824   float result;
7825
7826   arg1 = (Dali::Vector4 *)jarg1;
7827   result = (float) ((arg1)->z);
7828   jresult = result;
7829   return jresult;
7830 }
7831
7832
7833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7835   float arg2 ;
7836
7837   arg1 = (Dali::Vector4 *)jarg1;
7838   arg2 = (float)jarg2;
7839   if (arg1) (arg1)->b = arg2;
7840 }
7841
7842
7843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7844   float jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   float result;
7847
7848   arg1 = (Dali::Vector4 *)jarg1;
7849   result = (float) ((arg1)->b);
7850   jresult = result;
7851   return jresult;
7852 }
7853
7854
7855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7856   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7857   float arg2 ;
7858
7859   arg1 = (Dali::Vector4 *)jarg1;
7860   arg2 = (float)jarg2;
7861   if (arg1) (arg1)->p = arg2;
7862 }
7863
7864
7865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7866   float jresult ;
7867   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7868   float result;
7869
7870   arg1 = (Dali::Vector4 *)jarg1;
7871   result = (float) ((arg1)->p);
7872   jresult = result;
7873   return jresult;
7874 }
7875
7876
7877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7879   float arg2 ;
7880
7881   arg1 = (Dali::Vector4 *)jarg1;
7882   arg2 = (float)jarg2;
7883   if (arg1) (arg1)->w = arg2;
7884 }
7885
7886
7887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7888   float jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float result;
7891
7892   arg1 = (Dali::Vector4 *)jarg1;
7893   result = (float) ((arg1)->w);
7894   jresult = result;
7895   return jresult;
7896 }
7897
7898
7899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7900   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7901   float arg2 ;
7902
7903   arg1 = (Dali::Vector4 *)jarg1;
7904   arg2 = (float)jarg2;
7905   if (arg1) (arg1)->a = arg2;
7906 }
7907
7908
7909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7910   float jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   float result;
7913
7914   arg1 = (Dali::Vector4 *)jarg1;
7915   result = (float) ((arg1)->a);
7916   jresult = result;
7917   return jresult;
7918 }
7919
7920
7921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7922   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7923   float arg2 ;
7924
7925   arg1 = (Dali::Vector4 *)jarg1;
7926   arg2 = (float)jarg2;
7927   if (arg1) (arg1)->q = arg2;
7928 }
7929
7930
7931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7932   float jresult ;
7933   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7934   float result;
7935
7936   arg1 = (Dali::Vector4 *)jarg1;
7937   result = (float) ((arg1)->q);
7938   jresult = result;
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   {
7948     try {
7949       delete arg1;
7950     } catch (std::out_of_range& e) {
7951       {
7952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7953       };
7954     } catch (std::exception& e) {
7955       {
7956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7957       };
7958     } catch (...) {
7959       {
7960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7961       };
7962     }
7963   }
7964 }
7965
7966
7967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7968   void * jresult ;
7969   Dali::Vector4 *arg1 = 0 ;
7970   Dali::Vector4 *arg2 = 0 ;
7971   Dali::Vector4 result;
7972
7973   arg1 = (Dali::Vector4 *)jarg1;
7974   if (!arg1) {
7975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7976     return 0;
7977   }
7978   arg2 = (Dali::Vector4 *)jarg2;
7979   if (!arg2) {
7980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7981     return 0;
7982   }
7983   {
7984     try {
7985       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7986     } catch (std::out_of_range& e) {
7987       {
7988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (std::exception& e) {
7991       {
7992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (...) {
7995       {
7996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7997       };
7998     }
7999   }
8000   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8001   return jresult;
8002 }
8003
8004
8005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8006   void * jresult ;
8007   Dali::Vector4 *arg1 = 0 ;
8008   Dali::Vector4 *arg2 = 0 ;
8009   Dali::Vector4 result;
8010
8011   arg1 = (Dali::Vector4 *)jarg1;
8012   if (!arg1) {
8013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8014     return 0;
8015   }
8016   arg2 = (Dali::Vector4 *)jarg2;
8017   if (!arg2) {
8018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8019     return 0;
8020   }
8021   {
8022     try {
8023       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8024     } catch (std::out_of_range& e) {
8025       {
8026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (std::exception& e) {
8029       {
8030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (...) {
8033       {
8034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8035       };
8036     }
8037   }
8038   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8039   return jresult;
8040 }
8041
8042
8043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8044   void * jresult ;
8045   Dali::Vector4 *arg1 = 0 ;
8046   float *arg2 = 0 ;
8047   float *arg3 = 0 ;
8048   float temp2 ;
8049   float temp3 ;
8050   Dali::Vector4 result;
8051
8052   arg1 = (Dali::Vector4 *)jarg1;
8053   if (!arg1) {
8054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8055     return 0;
8056   }
8057   temp2 = (float)jarg2;
8058   arg2 = &temp2;
8059   temp3 = (float)jarg3;
8060   arg3 = &temp3;
8061   {
8062     try {
8063       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8064     } catch (std::out_of_range& e) {
8065       {
8066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (std::exception& e) {
8069       {
8070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (...) {
8073       {
8074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8075       };
8076     }
8077   }
8078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8079   return jresult;
8080 }
8081
8082
8083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8084   void * jresult ;
8085   Dali::Uint16Pair *result = 0 ;
8086
8087   {
8088     try {
8089       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8090     } catch (std::out_of_range& e) {
8091       {
8092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8093       };
8094     } catch (std::exception& e) {
8095       {
8096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8097       };
8098     } catch (...) {
8099       {
8100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8101       };
8102     }
8103   }
8104   jresult = (void *)result;
8105   return jresult;
8106 }
8107
8108
8109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8110   void * jresult ;
8111   uint32_t arg1 ;
8112   uint32_t arg2 ;
8113   Dali::Uint16Pair *result = 0 ;
8114
8115   arg1 = (uint32_t)jarg1;
8116   arg2 = (uint32_t)jarg2;
8117   {
8118     try {
8119       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8120     } catch (std::out_of_range& e) {
8121       {
8122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8123       };
8124     } catch (std::exception& e) {
8125       {
8126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8127       };
8128     } catch (...) {
8129       {
8130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8131       };
8132     }
8133   }
8134   jresult = (void *)result;
8135   return jresult;
8136 }
8137
8138
8139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8140   void * jresult ;
8141   Dali::Uint16Pair *arg1 = 0 ;
8142   Dali::Uint16Pair *result = 0 ;
8143
8144   arg1 = (Dali::Uint16Pair *)jarg1;
8145   if (!arg1) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (...) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8163       };
8164     }
8165   }
8166   jresult = (void *)result;
8167   return jresult;
8168 }
8169
8170
8171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8172   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8173   uint16_t arg2 ;
8174
8175   arg1 = (Dali::Uint16Pair *)jarg1;
8176   arg2 = (uint16_t)jarg2;
8177   {
8178     try {
8179       (arg1)->SetWidth(arg2);
8180     } catch (std::out_of_range& e) {
8181       {
8182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8183       };
8184     } catch (std::exception& e) {
8185       {
8186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8187       };
8188     } catch (...) {
8189       {
8190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8191       };
8192     }
8193   }
8194 }
8195
8196
8197 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8198   unsigned short jresult ;
8199   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8200   uint16_t result;
8201
8202   arg1 = (Dali::Uint16Pair *)jarg1;
8203   {
8204     try {
8205       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8206     } catch (std::out_of_range& e) {
8207       {
8208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8209       };
8210     } catch (std::exception& e) {
8211       {
8212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8213       };
8214     } catch (...) {
8215       {
8216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8217       };
8218     }
8219   }
8220   jresult = result;
8221   return jresult;
8222 }
8223
8224
8225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8226   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8227   uint16_t arg2 ;
8228
8229   arg1 = (Dali::Uint16Pair *)jarg1;
8230   arg2 = (uint16_t)jarg2;
8231   {
8232     try {
8233       (arg1)->SetHeight(arg2);
8234     } catch (std::out_of_range& e) {
8235       {
8236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8237       };
8238     } catch (std::exception& e) {
8239       {
8240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8241       };
8242     } catch (...) {
8243       {
8244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8245       };
8246     }
8247   }
8248 }
8249
8250
8251 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8252   unsigned short jresult ;
8253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8254   uint16_t result;
8255
8256   arg1 = (Dali::Uint16Pair *)jarg1;
8257   {
8258     try {
8259       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (...) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8271       };
8272     }
8273   }
8274   jresult = result;
8275   return jresult;
8276 }
8277
8278
8279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8281   uint16_t arg2 ;
8282
8283   arg1 = (Dali::Uint16Pair *)jarg1;
8284   arg2 = (uint16_t)jarg2;
8285   {
8286     try {
8287       (arg1)->SetX(arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8295       };
8296     } catch (...) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8299       };
8300     }
8301   }
8302 }
8303
8304
8305 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8306   unsigned short jresult ;
8307   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8308   uint16_t result;
8309
8310   arg1 = (Dali::Uint16Pair *)jarg1;
8311   {
8312     try {
8313       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8314     } catch (std::out_of_range& e) {
8315       {
8316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8317       };
8318     } catch (std::exception& e) {
8319       {
8320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8321       };
8322     } catch (...) {
8323       {
8324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8325       };
8326     }
8327   }
8328   jresult = result;
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8335   uint16_t arg2 ;
8336
8337   arg1 = (Dali::Uint16Pair *)jarg1;
8338   arg2 = (uint16_t)jarg2;
8339   {
8340     try {
8341       (arg1)->SetY(arg2);
8342     } catch (std::out_of_range& e) {
8343       {
8344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8345       };
8346     } catch (std::exception& e) {
8347       {
8348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8353       };
8354     }
8355   }
8356 }
8357
8358
8359 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8360   unsigned short jresult ;
8361   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8362   uint16_t result;
8363
8364   arg1 = (Dali::Uint16Pair *)jarg1;
8365   {
8366     try {
8367       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (...) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8379       };
8380     }
8381   }
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8388   void * jresult ;
8389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8390   Dali::Uint16Pair *arg2 = 0 ;
8391   Dali::Uint16Pair *result = 0 ;
8392
8393   arg1 = (Dali::Uint16Pair *)jarg1;
8394   arg2 = (Dali::Uint16Pair *)jarg2;
8395   if (!arg2) {
8396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8397     return 0;
8398   }
8399   {
8400     try {
8401       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8402     } catch (std::out_of_range& e) {
8403       {
8404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8405       };
8406     } catch (std::exception& e) {
8407       {
8408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (...) {
8411       {
8412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8413       };
8414     }
8415   }
8416   jresult = (void *)result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8422   unsigned int jresult ;
8423   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8424   Dali::Uint16Pair *arg2 = 0 ;
8425   bool result;
8426
8427   arg1 = (Dali::Uint16Pair *)jarg1;
8428   arg2 = (Dali::Uint16Pair *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8436     } catch (std::out_of_range& e) {
8437       {
8438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8439       };
8440     } catch (std::exception& e) {
8441       {
8442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8447       };
8448     }
8449   }
8450   jresult = result;
8451   return jresult;
8452 }
8453
8454
8455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8456   unsigned int jresult ;
8457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8458   Dali::Uint16Pair *arg2 = 0 ;
8459   bool result;
8460
8461   arg1 = (Dali::Uint16Pair *)jarg1;
8462   arg2 = (Dali::Uint16Pair *)jarg2;
8463   if (!arg2) {
8464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8465     return 0;
8466   }
8467   {
8468     try {
8469       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8470     } catch (std::out_of_range& e) {
8471       {
8472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8473       };
8474     } catch (std::exception& e) {
8475       {
8476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8477       };
8478     } catch (...) {
8479       {
8480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8481       };
8482     }
8483   }
8484   jresult = result;
8485   return jresult;
8486 }
8487
8488
8489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8490   unsigned int jresult ;
8491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8492   Dali::Uint16Pair *arg2 = 0 ;
8493   bool result;
8494
8495   arg1 = (Dali::Uint16Pair *)jarg1;
8496   arg2 = (Dali::Uint16Pair *)jarg2;
8497   if (!arg2) {
8498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8499     return 0;
8500   }
8501   {
8502     try {
8503       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (...) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8515       };
8516     }
8517   }
8518   jresult = result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8524   unsigned int jresult ;
8525   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8526   Dali::Uint16Pair *arg2 = 0 ;
8527   bool result;
8528
8529   arg1 = (Dali::Uint16Pair *)jarg1;
8530   arg2 = (Dali::Uint16Pair *)jarg2;
8531   if (!arg2) {
8532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8533     return 0;
8534   }
8535   {
8536     try {
8537       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8538     } catch (std::out_of_range& e) {
8539       {
8540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8541       };
8542     } catch (std::exception& e) {
8543       {
8544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8545       };
8546     } catch (...) {
8547       {
8548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8549       };
8550     }
8551   }
8552   jresult = result;
8553   return jresult;
8554 }
8555
8556
8557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8558   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8559
8560   arg1 = (Dali::Uint16Pair *)jarg1;
8561   {
8562     try {
8563       delete arg1;
8564     } catch (std::out_of_range& e) {
8565       {
8566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8567       };
8568     } catch (std::exception& e) {
8569       {
8570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8571       };
8572     } catch (...) {
8573       {
8574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8575       };
8576     }
8577   }
8578 }
8579
8580
8581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8582   void * jresult ;
8583   Dali::Degree *result = 0 ;
8584
8585   {
8586     try {
8587       result = (Dali::Degree *)new Dali::Degree();
8588     } catch (std::out_of_range& e) {
8589       {
8590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8591       };
8592     } catch (std::exception& e) {
8593       {
8594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8595       };
8596     } catch (...) {
8597       {
8598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8599       };
8600     }
8601   }
8602   jresult = (void *)result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8608   void * jresult ;
8609   float arg1 ;
8610   Dali::Degree *result = 0 ;
8611
8612   arg1 = (float)jarg1;
8613   {
8614     try {
8615       result = (Dali::Degree *)new Dali::Degree(arg1);
8616     } catch (std::out_of_range& e) {
8617       {
8618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8619       };
8620     } catch (std::exception& e) {
8621       {
8622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8623       };
8624     } catch (...) {
8625       {
8626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8627       };
8628     }
8629   }
8630   jresult = (void *)result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8636   void * jresult ;
8637   Dali::Radian arg1 ;
8638   Dali::Radian *argp1 ;
8639   Dali::Degree *result = 0 ;
8640
8641   argp1 = (Dali::Radian *)jarg1;
8642   if (!argp1) {
8643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8644     return 0;
8645   }
8646   arg1 = *argp1;
8647   {
8648     try {
8649       result = (Dali::Degree *)new Dali::Degree(arg1);
8650     } catch (std::out_of_range& e) {
8651       {
8652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8653       };
8654     } catch (std::exception& e) {
8655       {
8656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8657       };
8658     } catch (...) {
8659       {
8660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8661       };
8662     }
8663   }
8664   jresult = (void *)result;
8665   return jresult;
8666 }
8667
8668
8669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8670   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8671   float arg2 ;
8672
8673   arg1 = (Dali::Degree *)jarg1;
8674   arg2 = (float)jarg2;
8675   if (arg1) (arg1)->degree = arg2;
8676 }
8677
8678
8679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8680   float jresult ;
8681   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8682   float result;
8683
8684   arg1 = (Dali::Degree *)jarg1;
8685   result = (float) ((arg1)->degree);
8686   jresult = result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8692   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8693
8694   arg1 = (Dali::Degree *)jarg1;
8695   {
8696     try {
8697       delete arg1;
8698     } catch (std::out_of_range& e) {
8699       {
8700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8701       };
8702     } catch (std::exception& e) {
8703       {
8704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8705       };
8706     } catch (...) {
8707       {
8708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8709       };
8710     }
8711   }
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_360;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_315;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8736   void * jresult ;
8737   Dali::Radian *result = 0 ;
8738
8739   result = (Dali::Radian *)&Dali::ANGLE_270;
8740   jresult = (void *)result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8746   void * jresult ;
8747   Dali::Radian *result = 0 ;
8748
8749   result = (Dali::Radian *)&Dali::ANGLE_225;
8750   jresult = (void *)result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8756   void * jresult ;
8757   Dali::Radian *result = 0 ;
8758
8759   result = (Dali::Radian *)&Dali::ANGLE_180;
8760   jresult = (void *)result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8766   void * jresult ;
8767   Dali::Radian *result = 0 ;
8768
8769   result = (Dali::Radian *)&Dali::ANGLE_135;
8770   jresult = (void *)result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8776   void * jresult ;
8777   Dali::Radian *result = 0 ;
8778
8779   result = (Dali::Radian *)&Dali::ANGLE_120;
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8786   void * jresult ;
8787   Dali::Radian *result = 0 ;
8788
8789   result = (Dali::Radian *)&Dali::ANGLE_90;
8790   jresult = (void *)result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8796   void * jresult ;
8797   Dali::Radian *result = 0 ;
8798
8799   result = (Dali::Radian *)&Dali::ANGLE_60;
8800   jresult = (void *)result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8806   void * jresult ;
8807   Dali::Radian *result = 0 ;
8808
8809   result = (Dali::Radian *)&Dali::ANGLE_45;
8810   jresult = (void *)result;
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8816   void * jresult ;
8817   Dali::Radian *result = 0 ;
8818
8819   result = (Dali::Radian *)&Dali::ANGLE_30;
8820   jresult = (void *)result;
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8826   void * jresult ;
8827   Dali::Radian *result = 0 ;
8828
8829   result = (Dali::Radian *)&Dali::ANGLE_0;
8830   jresult = (void *)result;
8831   return jresult;
8832 }
8833
8834
8835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8836   unsigned int jresult ;
8837   Dali::Degree *arg1 = 0 ;
8838   Dali::Degree *arg2 = 0 ;
8839   bool result;
8840
8841   arg1 = (Dali::Degree *)jarg1;
8842   if (!arg1) {
8843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8844     return 0;
8845   }
8846   arg2 = (Dali::Degree *)jarg2;
8847   if (!arg2) {
8848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8849     return 0;
8850   }
8851   {
8852     try {
8853       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8854     } catch (std::out_of_range& e) {
8855       {
8856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8857       };
8858     } catch (std::exception& e) {
8859       {
8860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (...) {
8863       {
8864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8865       };
8866     }
8867   }
8868   jresult = result;
8869   return jresult;
8870 }
8871
8872
8873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8874   unsigned int jresult ;
8875   Dali::Degree *arg1 = 0 ;
8876   Dali::Degree *arg2 = 0 ;
8877   bool result;
8878
8879   arg1 = (Dali::Degree *)jarg1;
8880   if (!arg1) {
8881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8882     return 0;
8883   }
8884   arg2 = (Dali::Degree *)jarg2;
8885   if (!arg2) {
8886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8887     return 0;
8888   }
8889   {
8890     try {
8891       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8892     } catch (std::out_of_range& e) {
8893       {
8894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (std::exception& e) {
8897       {
8898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906   jresult = result;
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8912   void * jresult ;
8913   Dali::Degree arg1 ;
8914   float arg2 ;
8915   float arg3 ;
8916   Dali::Degree *argp1 ;
8917   Dali::Degree result;
8918
8919   argp1 = (Dali::Degree *)jarg1;
8920   if (!argp1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8922     return 0;
8923   }
8924   arg1 = *argp1;
8925   arg2 = (float)jarg2;
8926   arg3 = (float)jarg3;
8927   {
8928     try {
8929       result = Dali::Clamp(arg1,arg2,arg3);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (...) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8941       };
8942     }
8943   }
8944   jresult = new Dali::Degree((const Dali::Degree &)result);
8945   return jresult;
8946 }
8947
8948
8949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8950   void * jresult ;
8951   Dali::Radian *result = 0 ;
8952
8953   {
8954     try {
8955       result = (Dali::Radian *)new Dali::Radian();
8956     } catch (std::out_of_range& e) {
8957       {
8958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8959       };
8960     } catch (std::exception& e) {
8961       {
8962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8963       };
8964     } catch (...) {
8965       {
8966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8967       };
8968     }
8969   }
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8976   void * jresult ;
8977   float arg1 ;
8978   Dali::Radian *result = 0 ;
8979
8980   arg1 = (float)jarg1;
8981   {
8982     try {
8983       result = (Dali::Radian *)new Dali::Radian(arg1);
8984     } catch (std::out_of_range& e) {
8985       {
8986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8987       };
8988     } catch (std::exception& e) {
8989       {
8990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8991       };
8992     } catch (...) {
8993       {
8994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8995       };
8996     }
8997   }
8998   jresult = (void *)result;
8999   return jresult;
9000 }
9001
9002
9003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9004   void * jresult ;
9005   Dali::Degree arg1 ;
9006   Dali::Degree *argp1 ;
9007   Dali::Radian *result = 0 ;
9008
9009   argp1 = (Dali::Degree *)jarg1;
9010   if (!argp1) {
9011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9012     return 0;
9013   }
9014   arg1 = *argp1;
9015   {
9016     try {
9017       result = (Dali::Radian *)new Dali::Radian(arg1);
9018     } catch (std::out_of_range& e) {
9019       {
9020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9021       };
9022     } catch (std::exception& e) {
9023       {
9024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9025       };
9026     } catch (...) {
9027       {
9028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9029       };
9030     }
9031   }
9032   jresult = (void *)result;
9033   return jresult;
9034 }
9035
9036
9037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9038   void * jresult ;
9039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9040   float arg2 ;
9041   Dali::Radian *result = 0 ;
9042
9043   arg1 = (Dali::Radian *)jarg1;
9044   arg2 = (float)jarg2;
9045   {
9046     try {
9047       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9048     } catch (std::out_of_range& e) {
9049       {
9050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9051       };
9052     } catch (std::exception& e) {
9053       {
9054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9055       };
9056     } catch (...) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9059       };
9060     }
9061   }
9062   jresult = (void *)result;
9063   return jresult;
9064 }
9065
9066
9067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9068   void * jresult ;
9069   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9070   Dali::Degree arg2 ;
9071   Dali::Degree *argp2 ;
9072   Dali::Radian *result = 0 ;
9073
9074   arg1 = (Dali::Radian *)jarg1;
9075   argp2 = (Dali::Degree *)jarg2;
9076   if (!argp2) {
9077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9078     return 0;
9079   }
9080   arg2 = *argp2;
9081   {
9082     try {
9083       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9084     } catch (std::out_of_range& e) {
9085       {
9086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9087       };
9088     } catch (std::exception& e) {
9089       {
9090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9091       };
9092     } catch (...) {
9093       {
9094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9095       };
9096     }
9097   }
9098   jresult = (void *)result;
9099   return jresult;
9100 }
9101
9102
9103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9104   float jresult ;
9105   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9106   float result;
9107
9108   arg1 = (Dali::Radian *)jarg1;
9109   {
9110     try {
9111       result = (float)((Dali::Radian const *)arg1)->operator float();
9112     } catch (std::out_of_range& e) {
9113       {
9114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9115       };
9116     } catch (std::exception& e) {
9117       {
9118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9119       };
9120     } catch (...) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9123       };
9124     }
9125   }
9126   jresult = result;
9127   return jresult;
9128 }
9129
9130
9131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9133   float arg2 ;
9134
9135   arg1 = (Dali::Radian *)jarg1;
9136   arg2 = (float)jarg2;
9137   if (arg1) (arg1)->radian = arg2;
9138 }
9139
9140
9141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9142   float jresult ;
9143   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9144   float result;
9145
9146   arg1 = (Dali::Radian *)jarg1;
9147   result = (float) ((arg1)->radian);
9148   jresult = result;
9149   return jresult;
9150 }
9151
9152
9153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9155
9156   arg1 = (Dali::Radian *)jarg1;
9157   {
9158     try {
9159       delete arg1;
9160     } catch (std::out_of_range& e) {
9161       {
9162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9163       };
9164     } catch (std::exception& e) {
9165       {
9166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9167       };
9168     } catch (...) {
9169       {
9170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9171       };
9172     }
9173   }
9174 }
9175
9176
9177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9178   unsigned int jresult ;
9179   Dali::Radian arg1 ;
9180   Dali::Radian arg2 ;
9181   Dali::Radian *argp1 ;
9182   Dali::Radian *argp2 ;
9183   bool result;
9184
9185   argp1 = (Dali::Radian *)jarg1;
9186   if (!argp1) {
9187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9188     return 0;
9189   }
9190   arg1 = *argp1;
9191   argp2 = (Dali::Radian *)jarg2;
9192   if (!argp2) {
9193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9194     return 0;
9195   }
9196   arg2 = *argp2;
9197   {
9198     try {
9199       result = (bool)Dali::operator ==(arg1,arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9207       };
9208     } catch (...) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9211       };
9212     }
9213   }
9214   jresult = result;
9215   return jresult;
9216 }
9217
9218
9219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9220   unsigned int jresult ;
9221   Dali::Radian arg1 ;
9222   Dali::Radian arg2 ;
9223   Dali::Radian *argp1 ;
9224   Dali::Radian *argp2 ;
9225   bool result;
9226
9227   argp1 = (Dali::Radian *)jarg1;
9228   if (!argp1) {
9229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9230     return 0;
9231   }
9232   arg1 = *argp1;
9233   argp2 = (Dali::Radian *)jarg2;
9234   if (!argp2) {
9235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9236     return 0;
9237   }
9238   arg2 = *argp2;
9239   {
9240     try {
9241       result = (bool)Dali::operator !=(arg1,arg2);
9242     } catch (std::out_of_range& e) {
9243       {
9244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9245       };
9246     } catch (std::exception& e) {
9247       {
9248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (...) {
9251       {
9252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9253       };
9254     }
9255   }
9256   jresult = result;
9257   return jresult;
9258 }
9259
9260
9261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9262   unsigned int jresult ;
9263   Dali::Radian arg1 ;
9264   Dali::Degree arg2 ;
9265   Dali::Radian *argp1 ;
9266   Dali::Degree *argp2 ;
9267   bool result;
9268
9269   argp1 = (Dali::Radian *)jarg1;
9270   if (!argp1) {
9271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9272     return 0;
9273   }
9274   arg1 = *argp1;
9275   argp2 = (Dali::Degree *)jarg2;
9276   if (!argp2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9278     return 0;
9279   }
9280   arg2 = *argp2;
9281   {
9282     try {
9283       result = (bool)Dali::operator ==(arg1,arg2);
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (...) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9295       };
9296     }
9297   }
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9304   unsigned int jresult ;
9305   Dali::Radian arg1 ;
9306   Dali::Degree arg2 ;
9307   Dali::Radian *argp1 ;
9308   Dali::Degree *argp2 ;
9309   bool result;
9310
9311   argp1 = (Dali::Radian *)jarg1;
9312   if (!argp1) {
9313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9314     return 0;
9315   }
9316   arg1 = *argp1;
9317   argp2 = (Dali::Degree *)jarg2;
9318   if (!argp2) {
9319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9320     return 0;
9321   }
9322   arg2 = *argp2;
9323   {
9324     try {
9325       result = (bool)Dali::operator !=(arg1,arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (...) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9337       };
9338     }
9339   }
9340   jresult = result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Degree arg1 ;
9348   Dali::Radian arg2 ;
9349   Dali::Degree *argp1 ;
9350   Dali::Radian *argp2 ;
9351   bool result;
9352
9353   argp1 = (Dali::Degree *)jarg1;
9354   if (!argp1) {
9355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9356     return 0;
9357   }
9358   arg1 = *argp1;
9359   argp2 = (Dali::Radian *)jarg2;
9360   if (!argp2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9362     return 0;
9363   }
9364   arg2 = *argp2;
9365   {
9366     try {
9367       result = (bool)Dali::operator ==(arg1,arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (...) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9379       };
9380     }
9381   }
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Degree arg1 ;
9390   Dali::Radian arg2 ;
9391   Dali::Degree *argp1 ;
9392   Dali::Radian *argp2 ;
9393   bool result;
9394
9395   argp1 = (Dali::Degree *)jarg1;
9396   if (!argp1) {
9397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9398     return 0;
9399   }
9400   arg1 = *argp1;
9401   argp2 = (Dali::Radian *)jarg2;
9402   if (!argp2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9404     return 0;
9405   }
9406   arg2 = *argp2;
9407   {
9408     try {
9409       result = (bool)Dali::operator !=(arg1,arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9430   unsigned int jresult ;
9431   Dali::Radian arg1 ;
9432   Dali::Radian arg2 ;
9433   Dali::Radian *argp1 ;
9434   Dali::Radian *argp2 ;
9435   bool result;
9436
9437   argp1 = (Dali::Radian *)jarg1;
9438   if (!argp1) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9440     return 0;
9441   }
9442   arg1 = *argp1;
9443   argp2 = (Dali::Radian *)jarg2;
9444   if (!argp2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9446     return 0;
9447   }
9448   arg2 = *argp2;
9449   {
9450     try {
9451       result = (bool)Dali::operator >(arg1,arg2);
9452     } catch (std::out_of_range& e) {
9453       {
9454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (std::exception& e) {
9457       {
9458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466   jresult = result;
9467   return jresult;
9468 }
9469
9470
9471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9472   unsigned int jresult ;
9473   Dali::Radian arg1 ;
9474   Dali::Degree arg2 ;
9475   Dali::Radian *argp1 ;
9476   Dali::Degree *argp2 ;
9477   bool result;
9478
9479   argp1 = (Dali::Radian *)jarg1;
9480   if (!argp1) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9482     return 0;
9483   }
9484   arg1 = *argp1;
9485   argp2 = (Dali::Degree *)jarg2;
9486   if (!argp2) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9488     return 0;
9489   }
9490   arg2 = *argp2;
9491   {
9492     try {
9493       result = (bool)Dali::operator >(arg1,arg2);
9494     } catch (std::out_of_range& e) {
9495       {
9496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (std::exception& e) {
9499       {
9500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508   jresult = result;
9509   return jresult;
9510 }
9511
9512
9513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9514   unsigned int jresult ;
9515   Dali::Degree arg1 ;
9516   Dali::Radian arg2 ;
9517   Dali::Degree *argp1 ;
9518   Dali::Radian *argp2 ;
9519   bool result;
9520
9521   argp1 = (Dali::Degree *)jarg1;
9522   if (!argp1) {
9523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9524     return 0;
9525   }
9526   arg1 = *argp1;
9527   argp2 = (Dali::Radian *)jarg2;
9528   if (!argp2) {
9529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9530     return 0;
9531   }
9532   arg2 = *argp2;
9533   {
9534     try {
9535       result = (bool)Dali::operator >(arg1,arg2);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9547       };
9548     }
9549   }
9550   jresult = result;
9551   return jresult;
9552 }
9553
9554
9555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9556   unsigned int jresult ;
9557   Dali::Radian arg1 ;
9558   Dali::Radian arg2 ;
9559   Dali::Radian *argp1 ;
9560   Dali::Radian *argp2 ;
9561   bool result;
9562
9563   argp1 = (Dali::Radian *)jarg1;
9564   if (!argp1) {
9565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9566     return 0;
9567   }
9568   arg1 = *argp1;
9569   argp2 = (Dali::Radian *)jarg2;
9570   if (!argp2) {
9571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9572     return 0;
9573   }
9574   arg2 = *argp2;
9575   {
9576     try {
9577       result = (bool)Dali::operator <(arg1,arg2);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (...) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9589       };
9590     }
9591   }
9592   jresult = result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9598   unsigned int jresult ;
9599   Dali::Radian arg1 ;
9600   Dali::Degree arg2 ;
9601   Dali::Radian *argp1 ;
9602   Dali::Degree *argp2 ;
9603   bool result;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   argp2 = (Dali::Degree *)jarg2;
9612   if (!argp2) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9614     return 0;
9615   }
9616   arg2 = *argp2;
9617   {
9618     try {
9619       result = (bool)Dali::operator <(arg1,arg2);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (...) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9631       };
9632     }
9633   }
9634   jresult = result;
9635   return jresult;
9636 }
9637
9638
9639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9640   unsigned int jresult ;
9641   Dali::Degree arg1 ;
9642   Dali::Radian arg2 ;
9643   Dali::Degree *argp1 ;
9644   Dali::Radian *argp2 ;
9645   bool result;
9646
9647   argp1 = (Dali::Degree *)jarg1;
9648   if (!argp1) {
9649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9650     return 0;
9651   }
9652   arg1 = *argp1;
9653   argp2 = (Dali::Radian *)jarg2;
9654   if (!argp2) {
9655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9656     return 0;
9657   }
9658   arg2 = *argp2;
9659   {
9660     try {
9661       result = (bool)Dali::operator <(arg1,arg2);
9662     } catch (std::out_of_range& e) {
9663       {
9664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9665       };
9666     } catch (std::exception& e) {
9667       {
9668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9669       };
9670     } catch (...) {
9671       {
9672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9673       };
9674     }
9675   }
9676   jresult = result;
9677   return jresult;
9678 }
9679
9680
9681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9682   void * jresult ;
9683   Dali::Radian arg1 ;
9684   float arg2 ;
9685   Dali::Radian *argp1 ;
9686   Dali::Radian result;
9687
9688   argp1 = (Dali::Radian *)jarg1;
9689   if (!argp1) {
9690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9691     return 0;
9692   }
9693   arg1 = *argp1;
9694   arg2 = (float)jarg2;
9695   {
9696     try {
9697       result = Dali::operator *(arg1,arg2);
9698     } catch (std::out_of_range& e) {
9699       {
9700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (std::exception& e) {
9703       {
9704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9705       };
9706     } catch (...) {
9707       {
9708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9709       };
9710     }
9711   }
9712   jresult = new Dali::Radian((const Dali::Radian &)result);
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9718   void * jresult ;
9719   Dali::Radian arg1 ;
9720   Dali::Radian *argp1 ;
9721   Dali::Radian result;
9722
9723   argp1 = (Dali::Radian *)jarg1;
9724   if (!argp1) {
9725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9726     return 0;
9727   }
9728   arg1 = *argp1;
9729   {
9730     try {
9731       result = Dali::operator -(arg1);
9732     } catch (std::out_of_range& e) {
9733       {
9734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9735       };
9736     } catch (std::exception& e) {
9737       {
9738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (...) {
9741       {
9742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9743       };
9744     }
9745   }
9746   jresult = new Dali::Radian((const Dali::Radian &)result);
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9752   void * jresult ;
9753   Dali::Radian arg1 ;
9754   float arg2 ;
9755   float arg3 ;
9756   Dali::Radian *argp1 ;
9757   Dali::Radian result;
9758
9759   argp1 = (Dali::Radian *)jarg1;
9760   if (!argp1) {
9761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9762     return 0;
9763   }
9764   arg1 = *argp1;
9765   arg2 = (float)jarg2;
9766   arg3 = (float)jarg3;
9767   {
9768     try {
9769       result = Dali::Clamp(arg1,arg2,arg3);
9770     } catch (std::out_of_range& e) {
9771       {
9772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9773       };
9774     } catch (std::exception& e) {
9775       {
9776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9777       };
9778     } catch (...) {
9779       {
9780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9781       };
9782     }
9783   }
9784   jresult = new Dali::Radian((const Dali::Radian &)result);
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9790   void * jresult ;
9791   Dali::Quaternion *result = 0 ;
9792
9793   {
9794     try {
9795       result = (Dali::Quaternion *)new Dali::Quaternion();
9796     } catch (std::out_of_range& e) {
9797       {
9798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9799       };
9800     } catch (std::exception& e) {
9801       {
9802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9803       };
9804     } catch (...) {
9805       {
9806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9807       };
9808     }
9809   }
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9816   void * jresult ;
9817   Dali::Radian arg1 ;
9818   Dali::Vector3 *arg2 = 0 ;
9819   Dali::Radian *argp1 ;
9820   Dali::Quaternion *result = 0 ;
9821
9822   argp1 = (Dali::Radian *)jarg1;
9823   if (!argp1) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9825     return 0;
9826   }
9827   arg1 = *argp1;
9828   arg2 = (Dali::Vector3 *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850   jresult = (void *)result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9856   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9857
9858   arg1 = (Dali::Quaternion *)jarg1;
9859   {
9860     try {
9861       delete arg1;
9862     } catch (std::out_of_range& e) {
9863       {
9864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9865       };
9866     } catch (std::exception& e) {
9867       {
9868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9869       };
9870     } catch (...) {
9871       {
9872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9873       };
9874     }
9875   }
9876 }
9877
9878
9879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9880   void * jresult ;
9881   Dali::Quaternion *result = 0 ;
9882
9883   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9884   jresult = (void *)result;
9885   return jresult;
9886 }
9887
9888
9889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9890   unsigned int jresult ;
9891   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9892   bool result;
9893
9894   arg1 = (Dali::Quaternion *)jarg1;
9895   {
9896     try {
9897       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9898     } catch (std::out_of_range& e) {
9899       {
9900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9901       };
9902     } catch (std::exception& e) {
9903       {
9904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9905       };
9906     } catch (...) {
9907       {
9908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9909       };
9910     }
9911   }
9912   jresult = result;
9913   return jresult;
9914 }
9915
9916
9917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9918   unsigned int jresult ;
9919   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9920   Dali::Vector3 *arg2 = 0 ;
9921   Dali::Radian *arg3 = 0 ;
9922   bool result;
9923
9924   arg1 = (Dali::Quaternion *)jarg1;
9925   arg2 = (Dali::Vector3 *)jarg2;
9926   if (!arg2) {
9927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9928     return 0;
9929   }
9930   arg3 = (Dali::Radian *)jarg3;
9931   if (!arg3) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9938     } catch (std::out_of_range& e) {
9939       {
9940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (std::exception& e) {
9943       {
9944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9945       };
9946     } catch (...) {
9947       {
9948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9949       };
9950     }
9951   }
9952   jresult = result;
9953   return jresult;
9954 }
9955
9956
9957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9958   void * jresult ;
9959   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9960   Dali::Quaternion *arg2 = 0 ;
9961   Dali::Quaternion result;
9962
9963   arg1 = (Dali::Quaternion *)jarg1;
9964   arg2 = (Dali::Quaternion *)jarg2;
9965   if (!arg2) {
9966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9967     return 0;
9968   }
9969   {
9970     try {
9971       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9972     } catch (std::out_of_range& e) {
9973       {
9974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9975       };
9976     } catch (std::exception& e) {
9977       {
9978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (...) {
9981       {
9982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9983       };
9984     }
9985   }
9986   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9992   void * jresult ;
9993   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9994   Dali::Quaternion *arg2 = 0 ;
9995   Dali::Quaternion result;
9996
9997   arg1 = (Dali::Quaternion *)jarg1;
9998   arg2 = (Dali::Quaternion *)jarg2;
9999   if (!arg2) {
10000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10001     return 0;
10002   }
10003   {
10004     try {
10005       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10006     } catch (std::out_of_range& e) {
10007       {
10008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10009       };
10010     } catch (std::exception& e) {
10011       {
10012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10013       };
10014     } catch (...) {
10015       {
10016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10017       };
10018     }
10019   }
10020   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10026   void * jresult ;
10027   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10028   Dali::Quaternion *arg2 = 0 ;
10029   Dali::Quaternion result;
10030
10031   arg1 = (Dali::Quaternion *)jarg1;
10032   arg2 = (Dali::Quaternion *)jarg2;
10033   if (!arg2) {
10034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10035     return 0;
10036   }
10037   {
10038     try {
10039       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10040     } catch (std::out_of_range& e) {
10041       {
10042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (std::exception& e) {
10045       {
10046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10047       };
10048     } catch (...) {
10049       {
10050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10051       };
10052     }
10053   }
10054   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10055   return jresult;
10056 }
10057
10058
10059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10060   void * jresult ;
10061   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10062   Dali::Vector3 *arg2 = 0 ;
10063   Dali::Vector3 result;
10064
10065   arg1 = (Dali::Quaternion *)jarg1;
10066   arg2 = (Dali::Vector3 *)jarg2;
10067   if (!arg2) {
10068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10069     return 0;
10070   }
10071   {
10072     try {
10073       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10074     } catch (std::out_of_range& e) {
10075       {
10076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10077       };
10078     } catch (std::exception& e) {
10079       {
10080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10081       };
10082     } catch (...) {
10083       {
10084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10085       };
10086     }
10087   }
10088   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10089   return jresult;
10090 }
10091
10092
10093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10094   void * jresult ;
10095   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10096   Dali::Quaternion *arg2 = 0 ;
10097   Dali::Quaternion result;
10098
10099   arg1 = (Dali::Quaternion *)jarg1;
10100   arg2 = (Dali::Quaternion *)jarg2;
10101   if (!arg2) {
10102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10103     return 0;
10104   }
10105   {
10106     try {
10107       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10108     } catch (std::out_of_range& e) {
10109       {
10110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10111       };
10112     } catch (std::exception& e) {
10113       {
10114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10115       };
10116     } catch (...) {
10117       {
10118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10119       };
10120     }
10121   }
10122   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10123   return jresult;
10124 }
10125
10126
10127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10128   void * jresult ;
10129   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10130   float arg2 ;
10131   Dali::Quaternion result;
10132
10133   arg1 = (Dali::Quaternion *)jarg1;
10134   arg2 = (float)jarg2;
10135   {
10136     try {
10137       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10138     } catch (std::out_of_range& e) {
10139       {
10140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (std::exception& e) {
10143       {
10144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10158   void * jresult ;
10159   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10160   float arg2 ;
10161   Dali::Quaternion result;
10162
10163   arg1 = (Dali::Quaternion *)jarg1;
10164   arg2 = (float)jarg2;
10165   {
10166     try {
10167       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10168     } catch (std::out_of_range& e) {
10169       {
10170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10171       };
10172     } catch (std::exception& e) {
10173       {
10174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10175       };
10176     } catch (...) {
10177       {
10178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10179       };
10180     }
10181   }
10182   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10183   return jresult;
10184 }
10185
10186
10187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10188   void * jresult ;
10189   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10190   Dali::Quaternion result;
10191
10192   arg1 = (Dali::Quaternion *)jarg1;
10193   {
10194     try {
10195       result = ((Dali::Quaternion const *)arg1)->operator -();
10196     } catch (std::out_of_range& e) {
10197       {
10198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (std::exception& e) {
10201       {
10202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10207       };
10208     }
10209   }
10210   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10216   void * jresult ;
10217   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10218   Dali::Quaternion *arg2 = 0 ;
10219   Dali::Quaternion *result = 0 ;
10220
10221   arg1 = (Dali::Quaternion *)jarg1;
10222   arg2 = (Dali::Quaternion *)jarg2;
10223   if (!arg2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10225     return 0;
10226   }
10227   {
10228     try {
10229       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (...) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10241       };
10242     }
10243   }
10244   jresult = (void *)result;
10245   return jresult;
10246 }
10247
10248
10249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10250   void * jresult ;
10251   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10252   Dali::Quaternion *arg2 = 0 ;
10253   Dali::Quaternion *result = 0 ;
10254
10255   arg1 = (Dali::Quaternion *)jarg1;
10256   arg2 = (Dali::Quaternion *)jarg2;
10257   if (!arg2) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10259     return 0;
10260   }
10261   {
10262     try {
10263       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10264     } catch (std::out_of_range& e) {
10265       {
10266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10267       };
10268     } catch (std::exception& e) {
10269       {
10270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10271       };
10272     } catch (...) {
10273       {
10274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10275       };
10276     }
10277   }
10278   jresult = (void *)result;
10279   return jresult;
10280 }
10281
10282
10283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10284   void * jresult ;
10285   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10286   Dali::Quaternion *arg2 = 0 ;
10287   Dali::Quaternion *result = 0 ;
10288
10289   arg1 = (Dali::Quaternion *)jarg1;
10290   arg2 = (Dali::Quaternion *)jarg2;
10291   if (!arg2) {
10292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10293     return 0;
10294   }
10295   {
10296     try {
10297       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10298     } catch (std::out_of_range& e) {
10299       {
10300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10301       };
10302     } catch (std::exception& e) {
10303       {
10304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10305       };
10306     } catch (...) {
10307       {
10308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10309       };
10310     }
10311   }
10312   jresult = (void *)result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10318   void * jresult ;
10319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10320   float arg2 ;
10321   Dali::Quaternion *result = 0 ;
10322
10323   arg1 = (Dali::Quaternion *)jarg1;
10324   arg2 = (float)jarg2;
10325   {
10326     try {
10327       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10328     } catch (std::out_of_range& e) {
10329       {
10330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (std::exception& e) {
10333       {
10334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342   jresult = (void *)result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10348   void * jresult ;
10349   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10350   float arg2 ;
10351   Dali::Quaternion *result = 0 ;
10352
10353   arg1 = (Dali::Quaternion *)jarg1;
10354   arg2 = (float)jarg2;
10355   {
10356     try {
10357       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10358     } catch (std::out_of_range& e) {
10359       {
10360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (std::exception& e) {
10363       {
10364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10365       };
10366     } catch (...) {
10367       {
10368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10369       };
10370     }
10371   }
10372   jresult = (void *)result;
10373   return jresult;
10374 }
10375
10376
10377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10378   unsigned int jresult ;
10379   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10380   Dali::Quaternion *arg2 = 0 ;
10381   bool result;
10382
10383   arg1 = (Dali::Quaternion *)jarg1;
10384   arg2 = (Dali::Quaternion *)jarg2;
10385   if (!arg2) {
10386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10387     return 0;
10388   }
10389   {
10390     try {
10391       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10392     } catch (std::out_of_range& e) {
10393       {
10394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10395       };
10396     } catch (std::exception& e) {
10397       {
10398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10399       };
10400     } catch (...) {
10401       {
10402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10403       };
10404     }
10405   }
10406   jresult = result;
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10412   unsigned int jresult ;
10413   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10414   Dali::Quaternion *arg2 = 0 ;
10415   bool result;
10416
10417   arg1 = (Dali::Quaternion *)jarg1;
10418   arg2 = (Dali::Quaternion *)jarg2;
10419   if (!arg2) {
10420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10421     return 0;
10422   }
10423   {
10424     try {
10425       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10426     } catch (std::out_of_range& e) {
10427       {
10428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10429       };
10430     } catch (std::exception& e) {
10431       {
10432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10433       };
10434     } catch (...) {
10435       {
10436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10437       };
10438     }
10439   }
10440   jresult = result;
10441   return jresult;
10442 }
10443
10444
10445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10446   float jresult ;
10447   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10448   float result;
10449
10450   arg1 = (Dali::Quaternion *)jarg1;
10451   {
10452     try {
10453       result = (float)((Dali::Quaternion const *)arg1)->Length();
10454     } catch (std::out_of_range& e) {
10455       {
10456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (std::exception& e) {
10459       {
10460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (...) {
10463       {
10464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10465       };
10466     }
10467   }
10468   jresult = result;
10469   return jresult;
10470 }
10471
10472
10473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10474   float jresult ;
10475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10476   float result;
10477
10478   arg1 = (Dali::Quaternion *)jarg1;
10479   {
10480     try {
10481       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10482     } catch (std::out_of_range& e) {
10483       {
10484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10485       };
10486     } catch (std::exception& e) {
10487       {
10488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10489       };
10490     } catch (...) {
10491       {
10492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10493       };
10494     }
10495   }
10496   jresult = result;
10497   return jresult;
10498 }
10499
10500
10501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503
10504   arg1 = (Dali::Quaternion *)jarg1;
10505   {
10506     try {
10507       (arg1)->Normalize();
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10515       };
10516     } catch (...) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10519       };
10520     }
10521   }
10522 }
10523
10524
10525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10526   void * jresult ;
10527   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10528   Dali::Quaternion result;
10529
10530   arg1 = (Dali::Quaternion *)jarg1;
10531   {
10532     try {
10533       result = ((Dali::Quaternion const *)arg1)->Normalized();
10534     } catch (std::out_of_range& e) {
10535       {
10536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10537       };
10538     } catch (std::exception& e) {
10539       {
10540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10541       };
10542     } catch (...) {
10543       {
10544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10545       };
10546     }
10547   }
10548   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10549   return jresult;
10550 }
10551
10552
10553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10554   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10555
10556   arg1 = (Dali::Quaternion *)jarg1;
10557   {
10558     try {
10559       (arg1)->Conjugate();
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10571       };
10572     }
10573   }
10574 }
10575
10576
10577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10578   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10579
10580   arg1 = (Dali::Quaternion *)jarg1;
10581   {
10582     try {
10583       (arg1)->Invert();
10584     } catch (std::out_of_range& e) {
10585       {
10586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10587       };
10588     } catch (std::exception& e) {
10589       {
10590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10591       };
10592     } catch (...) {
10593       {
10594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10595       };
10596     }
10597   }
10598 }
10599
10600
10601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10602   void * jresult ;
10603   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10604   Dali::Quaternion result;
10605
10606   arg1 = (Dali::Quaternion *)jarg1;
10607   {
10608     try {
10609       result = ((Dali::Quaternion const *)arg1)->Log();
10610     } catch (std::out_of_range& e) {
10611       {
10612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (std::exception& e) {
10615       {
10616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10630   void * jresult ;
10631   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10632   Dali::Quaternion result;
10633
10634   arg1 = (Dali::Quaternion *)jarg1;
10635   {
10636     try {
10637       result = ((Dali::Quaternion const *)arg1)->Exp();
10638     } catch (std::out_of_range& e) {
10639       {
10640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (std::exception& e) {
10643       {
10644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (...) {
10647       {
10648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10649       };
10650     }
10651   }
10652   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10653   return jresult;
10654 }
10655
10656
10657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10658   float jresult ;
10659   Dali::Quaternion *arg1 = 0 ;
10660   Dali::Quaternion *arg2 = 0 ;
10661   float result;
10662
10663   arg1 = (Dali::Quaternion *)jarg1;
10664   if (!arg1) {
10665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10666     return 0;
10667   }
10668   arg2 = (Dali::Quaternion *)jarg2;
10669   if (!arg2) {
10670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10671     return 0;
10672   }
10673   {
10674     try {
10675       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10676     } catch (std::out_of_range& e) {
10677       {
10678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10679       };
10680     } catch (std::exception& e) {
10681       {
10682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10683       };
10684     } catch (...) {
10685       {
10686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10687       };
10688     }
10689   }
10690   jresult = result;
10691   return jresult;
10692 }
10693
10694
10695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10696   void * jresult ;
10697   Dali::Quaternion *arg1 = 0 ;
10698   Dali::Quaternion *arg2 = 0 ;
10699   float arg3 ;
10700   Dali::Quaternion result;
10701
10702   arg1 = (Dali::Quaternion *)jarg1;
10703   if (!arg1) {
10704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10705     return 0;
10706   }
10707   arg2 = (Dali::Quaternion *)jarg2;
10708   if (!arg2) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10710     return 0;
10711   }
10712   arg3 = (float)jarg3;
10713   {
10714     try {
10715       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10716     } catch (std::out_of_range& e) {
10717       {
10718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (std::exception& e) {
10721       {
10722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10723       };
10724     } catch (...) {
10725       {
10726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10727       };
10728     }
10729   }
10730   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10731   return jresult;
10732 }
10733
10734
10735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10736   void * jresult ;
10737   Dali::Quaternion *arg1 = 0 ;
10738   Dali::Quaternion *arg2 = 0 ;
10739   float arg3 ;
10740   Dali::Quaternion result;
10741
10742   arg1 = (Dali::Quaternion *)jarg1;
10743   if (!arg1) {
10744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10745     return 0;
10746   }
10747   arg2 = (Dali::Quaternion *)jarg2;
10748   if (!arg2) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10750     return 0;
10751   }
10752   arg3 = (float)jarg3;
10753   {
10754     try {
10755       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10756     } catch (std::out_of_range& e) {
10757       {
10758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10759       };
10760     } catch (std::exception& e) {
10761       {
10762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10763       };
10764     } catch (...) {
10765       {
10766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10767       };
10768     }
10769   }
10770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10771   return jresult;
10772 }
10773
10774
10775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10776   void * jresult ;
10777   Dali::Quaternion *arg1 = 0 ;
10778   Dali::Quaternion *arg2 = 0 ;
10779   float arg3 ;
10780   Dali::Quaternion result;
10781
10782   arg1 = (Dali::Quaternion *)jarg1;
10783   if (!arg1) {
10784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10785     return 0;
10786   }
10787   arg2 = (Dali::Quaternion *)jarg2;
10788   if (!arg2) {
10789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10790     return 0;
10791   }
10792   arg3 = (float)jarg3;
10793   {
10794     try {
10795       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10803       };
10804     } catch (...) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10807       };
10808     }
10809   }
10810   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10811   return jresult;
10812 }
10813
10814
10815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10816   void * jresult ;
10817   Dali::Quaternion *arg1 = 0 ;
10818   Dali::Quaternion *arg2 = 0 ;
10819   Dali::Quaternion *arg3 = 0 ;
10820   Dali::Quaternion *arg4 = 0 ;
10821   float arg5 ;
10822   Dali::Quaternion result;
10823
10824   arg1 = (Dali::Quaternion *)jarg1;
10825   if (!arg1) {
10826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10827     return 0;
10828   }
10829   arg2 = (Dali::Quaternion *)jarg2;
10830   if (!arg2) {
10831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10832     return 0;
10833   }
10834   arg3 = (Dali::Quaternion *)jarg3;
10835   if (!arg3) {
10836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10837     return 0;
10838   }
10839   arg4 = (Dali::Quaternion *)jarg4;
10840   if (!arg4) {
10841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10842     return 0;
10843   }
10844   arg5 = (float)jarg5;
10845   {
10846     try {
10847       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10848     } catch (std::out_of_range& e) {
10849       {
10850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10851       };
10852     } catch (std::exception& e) {
10853       {
10854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (...) {
10857       {
10858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10859       };
10860     }
10861   }
10862   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10863   return jresult;
10864 }
10865
10866
10867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10868   float jresult ;
10869   Dali::Quaternion *arg1 = 0 ;
10870   Dali::Quaternion *arg2 = 0 ;
10871   float result;
10872
10873   arg1 = (Dali::Quaternion *)jarg1;
10874   if (!arg1) {
10875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10876     return 0;
10877   }
10878   arg2 = (Dali::Quaternion *)jarg2;
10879   if (!arg2) {
10880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10881     return 0;
10882   }
10883   {
10884     try {
10885       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10886     } catch (std::out_of_range& e) {
10887       {
10888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10889       };
10890     } catch (std::exception& e) {
10891       {
10892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (...) {
10895       {
10896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10897       };
10898     }
10899   }
10900   jresult = result;
10901   return jresult;
10902 }
10903
10904
10905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10906   void * jresult ;
10907   Dali::Matrix *result = 0 ;
10908
10909   {
10910     try {
10911       result = (Dali::Matrix *)new Dali::Matrix();
10912     } catch (std::out_of_range& e) {
10913       {
10914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (std::exception& e) {
10917       {
10918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10923       };
10924     }
10925   }
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10932   void * jresult ;
10933   bool arg1 ;
10934   Dali::Matrix *result = 0 ;
10935
10936   arg1 = jarg1 ? true : false;
10937   {
10938     try {
10939       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10940     } catch (std::out_of_range& e) {
10941       {
10942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10943       };
10944     } catch (std::exception& e) {
10945       {
10946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (...) {
10949       {
10950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10951       };
10952     }
10953   }
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10960   void * jresult ;
10961   float *arg1 = (float *) 0 ;
10962   Dali::Matrix *result = 0 ;
10963
10964   arg1 = jarg1;
10965   {
10966     try {
10967       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10968     } catch (std::out_of_range& e) {
10969       {
10970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (std::exception& e) {
10973       {
10974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10975       };
10976     } catch (...) {
10977       {
10978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10979       };
10980     }
10981   }
10982   jresult = (void *)result;
10983
10984
10985   return jresult;
10986 }
10987
10988
10989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10990   void * jresult ;
10991   Dali::Quaternion *arg1 = 0 ;
10992   Dali::Matrix *result = 0 ;
10993
10994   arg1 = (Dali::Quaternion *)jarg1;
10995   if (!arg1) {
10996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10997     return 0;
10998   }
10999   {
11000     try {
11001       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11002     } catch (std::out_of_range& e) {
11003       {
11004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11005       };
11006     } catch (std::exception& e) {
11007       {
11008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11009       };
11010     } catch (...) {
11011       {
11012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11013       };
11014     }
11015   }
11016   jresult = (void *)result;
11017   return jresult;
11018 }
11019
11020
11021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11022   void * jresult ;
11023   Dali::Matrix *arg1 = 0 ;
11024   Dali::Matrix *result = 0 ;
11025
11026   arg1 = (Dali::Matrix *)jarg1;
11027   if (!arg1) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11029     return 0;
11030   }
11031   {
11032     try {
11033       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11045       };
11046     }
11047   }
11048   jresult = (void *)result;
11049   return jresult;
11050 }
11051
11052
11053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11054   void * jresult ;
11055   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11056   Dali::Matrix *arg2 = 0 ;
11057   Dali::Matrix *result = 0 ;
11058
11059   arg1 = (Dali::Matrix *)jarg1;
11060   arg2 = (Dali::Matrix *)jarg2;
11061   if (!arg2) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11068     } catch (std::out_of_range& e) {
11069       {
11070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11071       };
11072     } catch (std::exception& e) {
11073       {
11074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11075       };
11076     } catch (...) {
11077       {
11078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11079       };
11080     }
11081   }
11082   jresult = (void *)result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11088   void * jresult ;
11089   Dali::Matrix *result = 0 ;
11090
11091   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11092   jresult = (void *)result;
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11099
11100   arg1 = (Dali::Matrix *)jarg1;
11101   {
11102     try {
11103       (arg1)->SetIdentity();
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11111       };
11112     } catch (...) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11115       };
11116     }
11117   }
11118 }
11119
11120
11121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11122   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11123   Dali::Vector3 *arg2 = 0 ;
11124
11125   arg1 = (Dali::Matrix *)jarg1;
11126   arg2 = (Dali::Vector3 *)jarg2;
11127   if (!arg2) {
11128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11129     return ;
11130   }
11131   {
11132     try {
11133       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11134     } catch (std::out_of_range& e) {
11135       {
11136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11137       };
11138     } catch (std::exception& e) {
11139       {
11140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11145       };
11146     }
11147   }
11148 }
11149
11150
11151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11152   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11153   Dali::Matrix *arg2 = 0 ;
11154
11155   arg1 = (Dali::Matrix *)jarg1;
11156   arg2 = (Dali::Matrix *)jarg2;
11157   if (!arg2) {
11158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11159     return ;
11160   }
11161   {
11162     try {
11163       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11164     } catch (std::out_of_range& e) {
11165       {
11166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11167       };
11168     } catch (std::exception& e) {
11169       {
11170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11171       };
11172     } catch (...) {
11173       {
11174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11175       };
11176     }
11177   }
11178 }
11179
11180
11181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11182   unsigned int jresult ;
11183   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11184   bool result;
11185
11186   arg1 = (Dali::Matrix *)jarg1;
11187   {
11188     try {
11189       result = (bool)(arg1)->Invert();
11190     } catch (std::out_of_range& e) {
11191       {
11192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11193       };
11194     } catch (std::exception& e) {
11195       {
11196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11197       };
11198     } catch (...) {
11199       {
11200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11201       };
11202     }
11203   }
11204   jresult = result;
11205   return jresult;
11206 }
11207
11208
11209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11210   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11211
11212   arg1 = (Dali::Matrix *)jarg1;
11213   {
11214     try {
11215       (arg1)->Transpose();
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11223       };
11224     } catch (...) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11227       };
11228     }
11229   }
11230 }
11231
11232
11233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11234   void * jresult ;
11235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11236   Dali::Vector3 result;
11237
11238   arg1 = (Dali::Matrix *)jarg1;
11239   {
11240     try {
11241       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11242     } catch (std::out_of_range& e) {
11243       {
11244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11245       };
11246     } catch (std::exception& e) {
11247       {
11248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (...) {
11251       {
11252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11253       };
11254     }
11255   }
11256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11257   return jresult;
11258 }
11259
11260
11261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11262   void * jresult ;
11263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11264   Dali::Vector3 result;
11265
11266   arg1 = (Dali::Matrix *)jarg1;
11267   {
11268     try {
11269       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11270     } catch (std::out_of_range& e) {
11271       {
11272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11273       };
11274     } catch (std::exception& e) {
11275       {
11276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11277       };
11278     } catch (...) {
11279       {
11280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11281       };
11282     }
11283   }
11284   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11290   void * jresult ;
11291   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11292   Dali::Vector3 result;
11293
11294   arg1 = (Dali::Matrix *)jarg1;
11295   {
11296     try {
11297       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11298     } catch (std::out_of_range& e) {
11299       {
11300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (std::exception& e) {
11303       {
11304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11305       };
11306     } catch (...) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11309       };
11310     }
11311   }
11312   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11318   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11319   Dali::Vector3 *arg2 = 0 ;
11320
11321   arg1 = (Dali::Matrix *)jarg1;
11322   arg2 = (Dali::Vector3 *)jarg2;
11323   if (!arg2) {
11324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11325     return ;
11326   }
11327   {
11328     try {
11329       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11337       };
11338     } catch (...) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11341       };
11342     }
11343   }
11344 }
11345
11346
11347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11348   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11349   Dali::Vector3 *arg2 = 0 ;
11350
11351   arg1 = (Dali::Matrix *)jarg1;
11352   arg2 = (Dali::Vector3 *)jarg2;
11353   if (!arg2) {
11354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11355     return ;
11356   }
11357   {
11358     try {
11359       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11367       };
11368     } catch (...) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11371       };
11372     }
11373   }
11374 }
11375
11376
11377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11378   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11379   Dali::Vector3 *arg2 = 0 ;
11380
11381   arg1 = (Dali::Matrix *)jarg1;
11382   arg2 = (Dali::Vector3 *)jarg2;
11383   if (!arg2) {
11384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11385     return ;
11386   }
11387   {
11388     try {
11389       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11390     } catch (std::out_of_range& e) {
11391       {
11392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11393       };
11394     } catch (std::exception& e) {
11395       {
11396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11397       };
11398     } catch (...) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11401       };
11402     }
11403   }
11404 }
11405
11406
11407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11408   void * jresult ;
11409   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11410   Dali::Vector4 *result = 0 ;
11411
11412   arg1 = (Dali::Matrix *)jarg1;
11413   {
11414     try {
11415       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11416     } catch (std::out_of_range& e) {
11417       {
11418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11419       };
11420     } catch (std::exception& e) {
11421       {
11422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11423       };
11424     } catch (...) {
11425       {
11426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11427       };
11428     }
11429   }
11430   jresult = (void *)result;
11431   return jresult;
11432 }
11433
11434
11435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11436   void * jresult ;
11437   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11438   Dali::Vector3 *result = 0 ;
11439
11440   arg1 = (Dali::Matrix *)jarg1;
11441   {
11442     try {
11443       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11444     } catch (std::out_of_range& e) {
11445       {
11446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (std::exception& e) {
11449       {
11450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11451       };
11452     } catch (...) {
11453       {
11454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11455       };
11456     }
11457   }
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11464   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11465   Dali::Vector4 *arg2 = 0 ;
11466
11467   arg1 = (Dali::Matrix *)jarg1;
11468   arg2 = (Dali::Vector4 *)jarg2;
11469   if (!arg2) {
11470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11471     return ;
11472   }
11473   {
11474     try {
11475       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11476     } catch (std::out_of_range& e) {
11477       {
11478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11479       };
11480     } catch (std::exception& e) {
11481       {
11482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11483       };
11484     } catch (...) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11487       };
11488     }
11489   }
11490 }
11491
11492
11493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11494   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11495   Dali::Vector3 *arg2 = 0 ;
11496
11497   arg1 = (Dali::Matrix *)jarg1;
11498   arg2 = (Dali::Vector3 *)jarg2;
11499   if (!arg2) {
11500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11501     return ;
11502   }
11503   {
11504     try {
11505       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11506     } catch (std::out_of_range& e) {
11507       {
11508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11509       };
11510     } catch (std::exception& e) {
11511       {
11512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11517       };
11518     }
11519   }
11520 }
11521
11522
11523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11524   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11525
11526   arg1 = (Dali::Matrix *)jarg1;
11527   {
11528     try {
11529       (arg1)->OrthoNormalize();
11530     } catch (std::out_of_range& e) {
11531       {
11532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11533       };
11534     } catch (std::exception& e) {
11535       {
11536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11537       };
11538     } catch (...) {
11539       {
11540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11541       };
11542     }
11543   }
11544 }
11545
11546
11547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11548   void * jresult ;
11549   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11550   float *result = 0 ;
11551
11552   arg1 = (Dali::Matrix *)jarg1;
11553   {
11554     try {
11555       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11563       };
11564     } catch (...) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11567       };
11568     }
11569   }
11570   jresult = (void *)result;
11571   return jresult;
11572 }
11573
11574
11575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11576   Dali::Matrix *arg1 = 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   Dali::Matrix *arg3 = 0 ;
11579
11580   arg1 = (Dali::Matrix *)jarg1;
11581   if (!arg1) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11583     return ;
11584   }
11585   arg2 = (Dali::Matrix *)jarg2;
11586   if (!arg2) {
11587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11588     return ;
11589   }
11590   arg3 = (Dali::Matrix *)jarg3;
11591   if (!arg3) {
11592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11593     return ;
11594   }
11595   {
11596     try {
11597       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11598     } catch (std::out_of_range& e) {
11599       {
11600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11601       };
11602     } catch (std::exception& e) {
11603       {
11604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11605       };
11606     } catch (...) {
11607       {
11608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11609       };
11610     }
11611   }
11612 }
11613
11614
11615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11616   Dali::Matrix *arg1 = 0 ;
11617   Dali::Matrix *arg2 = 0 ;
11618   Dali::Quaternion *arg3 = 0 ;
11619
11620   arg1 = (Dali::Matrix *)jarg1;
11621   if (!arg1) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11623     return ;
11624   }
11625   arg2 = (Dali::Matrix *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11628     return ;
11629   }
11630   arg3 = (Dali::Quaternion *)jarg3;
11631   if (!arg3) {
11632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11633     return ;
11634   }
11635   {
11636     try {
11637       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11638     } catch (std::out_of_range& e) {
11639       {
11640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11641       };
11642     } catch (std::exception& e) {
11643       {
11644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11645       };
11646     } catch (...) {
11647       {
11648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11649       };
11650     }
11651   }
11652 }
11653
11654
11655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11656   void * jresult ;
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector4 *arg2 = 0 ;
11659   Dali::Vector4 result;
11660
11661   arg1 = (Dali::Matrix *)jarg1;
11662   arg2 = (Dali::Vector4 *)jarg2;
11663   if (!arg2) {
11664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11665     return 0;
11666   }
11667   {
11668     try {
11669       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11670     } catch (std::out_of_range& e) {
11671       {
11672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (std::exception& e) {
11675       {
11676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11677       };
11678     } catch (...) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11681       };
11682     }
11683   }
11684   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11685   return jresult;
11686 }
11687
11688
11689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11690   unsigned int jresult ;
11691   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11692   Dali::Matrix *arg2 = 0 ;
11693   bool result;
11694
11695   arg1 = (Dali::Matrix *)jarg1;
11696   arg2 = (Dali::Matrix *)jarg2;
11697   if (!arg2) {
11698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11699     return 0;
11700   }
11701   {
11702     try {
11703       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11704     } catch (std::out_of_range& e) {
11705       {
11706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11707       };
11708     } catch (std::exception& e) {
11709       {
11710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11711       };
11712     } catch (...) {
11713       {
11714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11715       };
11716     }
11717   }
11718   jresult = result;
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11724   unsigned int jresult ;
11725   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11726   Dali::Matrix *arg2 = 0 ;
11727   bool result;
11728
11729   arg1 = (Dali::Matrix *)jarg1;
11730   arg2 = (Dali::Matrix *)jarg2;
11731   if (!arg2) {
11732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11733     return 0;
11734   }
11735   {
11736     try {
11737       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11745       };
11746     } catch (...) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11749       };
11750     }
11751   }
11752   jresult = result;
11753   return jresult;
11754 }
11755
11756
11757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11759   Dali::Vector3 *arg2 = 0 ;
11760   Dali::Quaternion *arg3 = 0 ;
11761   Dali::Vector3 *arg4 = 0 ;
11762
11763   arg1 = (Dali::Matrix *)jarg1;
11764   arg2 = (Dali::Vector3 *)jarg2;
11765   if (!arg2) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11767     return ;
11768   }
11769   arg3 = (Dali::Quaternion *)jarg3;
11770   if (!arg3) {
11771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11772     return ;
11773   }
11774   arg4 = (Dali::Vector3 *)jarg4;
11775   if (!arg4) {
11776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11777     return ;
11778   }
11779   {
11780     try {
11781       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11782     } catch (std::out_of_range& e) {
11783       {
11784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11785       };
11786     } catch (std::exception& e) {
11787       {
11788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (...) {
11791       {
11792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11793       };
11794     }
11795   }
11796 }
11797
11798
11799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11800   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11801   Dali::Vector3 *arg2 = 0 ;
11802   Dali::Quaternion *arg3 = 0 ;
11803   Dali::Vector3 *arg4 = 0 ;
11804
11805   arg1 = (Dali::Matrix *)jarg1;
11806   arg2 = (Dali::Vector3 *)jarg2;
11807   if (!arg2) {
11808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11809     return ;
11810   }
11811   arg3 = (Dali::Quaternion *)jarg3;
11812   if (!arg3) {
11813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11814     return ;
11815   }
11816   arg4 = (Dali::Vector3 *)jarg4;
11817   if (!arg4) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11819     return ;
11820   }
11821   {
11822     try {
11823       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11824     } catch (std::out_of_range& e) {
11825       {
11826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11827       };
11828     } catch (std::exception& e) {
11829       {
11830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11831       };
11832     } catch (...) {
11833       {
11834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11835       };
11836     }
11837   }
11838 }
11839
11840
11841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11842   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11843   Dali::Vector3 *arg2 = 0 ;
11844   Dali::Vector3 *arg3 = 0 ;
11845   Dali::Vector3 *arg4 = 0 ;
11846   Dali::Vector3 *arg5 = 0 ;
11847
11848   arg1 = (Dali::Matrix *)jarg1;
11849   arg2 = (Dali::Vector3 *)jarg2;
11850   if (!arg2) {
11851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11852     return ;
11853   }
11854   arg3 = (Dali::Vector3 *)jarg3;
11855   if (!arg3) {
11856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11857     return ;
11858   }
11859   arg4 = (Dali::Vector3 *)jarg4;
11860   if (!arg4) {
11861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11862     return ;
11863   }
11864   arg5 = (Dali::Vector3 *)jarg5;
11865   if (!arg5) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11867     return ;
11868   }
11869   {
11870     try {
11871       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11879       };
11880     } catch (...) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11883       };
11884     }
11885   }
11886 }
11887
11888
11889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11890   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11891   Dali::Vector3 *arg2 = 0 ;
11892   Dali::Quaternion *arg3 = 0 ;
11893   Dali::Vector3 *arg4 = 0 ;
11894
11895   arg1 = (Dali::Matrix *)jarg1;
11896   arg2 = (Dali::Vector3 *)jarg2;
11897   if (!arg2) {
11898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11899     return ;
11900   }
11901   arg3 = (Dali::Quaternion *)jarg3;
11902   if (!arg3) {
11903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11904     return ;
11905   }
11906   arg4 = (Dali::Vector3 *)jarg4;
11907   if (!arg4) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11909     return ;
11910   }
11911   {
11912     try {
11913       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11914     } catch (std::out_of_range& e) {
11915       {
11916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11917       };
11918     } catch (std::exception& e) {
11919       {
11920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11925       };
11926     }
11927   }
11928 }
11929
11930
11931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11932   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11933
11934   arg1 = (Dali::Matrix *)jarg1;
11935   {
11936     try {
11937       delete arg1;
11938     } catch (std::out_of_range& e) {
11939       {
11940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11941       };
11942     } catch (std::exception& e) {
11943       {
11944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11945       };
11946     } catch (...) {
11947       {
11948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11949       };
11950     }
11951   }
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11956   void * jresult ;
11957   Dali::Matrix3 *result = 0 ;
11958
11959   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11960   jresult = (void *)result;
11961   return jresult;
11962 }
11963
11964
11965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11966   void * jresult ;
11967   Dali::Matrix3 *result = 0 ;
11968
11969   {
11970     try {
11971       result = (Dali::Matrix3 *)new Dali::Matrix3();
11972     } catch (std::out_of_range& e) {
11973       {
11974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (std::exception& e) {
11977       {
11978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986   jresult = (void *)result;
11987   return jresult;
11988 }
11989
11990
11991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11992   void * jresult ;
11993   Dali::Matrix3 *arg1 = 0 ;
11994   Dali::Matrix3 *result = 0 ;
11995
11996   arg1 = (Dali::Matrix3 *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11999     return 0;
12000   }
12001   {
12002     try {
12003       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12004     } catch (std::out_of_range& e) {
12005       {
12006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12007       };
12008     } catch (std::exception& e) {
12009       {
12010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (...) {
12013       {
12014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12015       };
12016     }
12017   }
12018   jresult = (void *)result;
12019   return jresult;
12020 }
12021
12022
12023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12024   void * jresult ;
12025   Dali::Matrix *arg1 = 0 ;
12026   Dali::Matrix3 *result = 0 ;
12027
12028   arg1 = (Dali::Matrix *)jarg1;
12029   if (!arg1) {
12030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12031     return 0;
12032   }
12033   {
12034     try {
12035       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12036     } catch (std::out_of_range& e) {
12037       {
12038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12039       };
12040     } catch (std::exception& e) {
12041       {
12042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12043       };
12044     } catch (...) {
12045       {
12046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12047       };
12048     }
12049   }
12050   jresult = (void *)result;
12051   return jresult;
12052 }
12053
12054
12055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
12056   void * jresult ;
12057   float arg1 ;
12058   float arg2 ;
12059   float arg3 ;
12060   float arg4 ;
12061   float arg5 ;
12062   float arg6 ;
12063   float arg7 ;
12064   float arg8 ;
12065   float arg9 ;
12066   Dali::Matrix3 *result = 0 ;
12067
12068   arg1 = (float)jarg1;
12069   arg2 = (float)jarg2;
12070   arg3 = (float)jarg3;
12071   arg4 = (float)jarg4;
12072   arg5 = (float)jarg5;
12073   arg6 = (float)jarg6;
12074   arg7 = (float)jarg7;
12075   arg8 = (float)jarg8;
12076   arg9 = (float)jarg9;
12077   {
12078     try {
12079       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12080     } catch (std::out_of_range& e) {
12081       {
12082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (std::exception& e) {
12085       {
12086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12087       };
12088     } catch (...) {
12089       {
12090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12091       };
12092     }
12093   }
12094   jresult = (void *)result;
12095   return jresult;
12096 }
12097
12098
12099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12100   void * jresult ;
12101   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12102   Dali::Matrix3 *arg2 = 0 ;
12103   Dali::Matrix3 *result = 0 ;
12104
12105   arg1 = (Dali::Matrix3 *)jarg1;
12106   arg2 = (Dali::Matrix3 *)jarg2;
12107   if (!arg2) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12109     return 0;
12110   }
12111   {
12112     try {
12113       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128   jresult = (void *)result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12134   void * jresult ;
12135   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12136   Dali::Matrix *arg2 = 0 ;
12137   Dali::Matrix3 *result = 0 ;
12138
12139   arg1 = (Dali::Matrix3 *)jarg1;
12140   arg2 = (Dali::Matrix *)jarg2;
12141   if (!arg2) {
12142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12143     return 0;
12144   }
12145   {
12146     try {
12147       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12148     } catch (std::out_of_range& e) {
12149       {
12150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12151       };
12152     } catch (std::exception& e) {
12153       {
12154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (...) {
12157       {
12158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12159       };
12160     }
12161   }
12162   jresult = (void *)result;
12163   return jresult;
12164 }
12165
12166
12167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12168   unsigned int jresult ;
12169   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12170   Dali::Matrix3 *arg2 = 0 ;
12171   bool result;
12172
12173   arg1 = (Dali::Matrix3 *)jarg1;
12174   arg2 = (Dali::Matrix3 *)jarg2;
12175   if (!arg2) {
12176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12177     return 0;
12178   }
12179   {
12180     try {
12181       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12182     } catch (std::out_of_range& e) {
12183       {
12184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12185       };
12186     } catch (std::exception& e) {
12187       {
12188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (...) {
12191       {
12192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12193       };
12194     }
12195   }
12196   jresult = result;
12197   return jresult;
12198 }
12199
12200
12201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12202   unsigned int jresult ;
12203   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12204   Dali::Matrix3 *arg2 = 0 ;
12205   bool result;
12206
12207   arg1 = (Dali::Matrix3 *)jarg1;
12208   arg2 = (Dali::Matrix3 *)jarg2;
12209   if (!arg2) {
12210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12211     return 0;
12212   }
12213   {
12214     try {
12215       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12216     } catch (std::out_of_range& e) {
12217       {
12218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12219       };
12220     } catch (std::exception& e) {
12221       {
12222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (...) {
12225       {
12226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12227       };
12228     }
12229   }
12230   jresult = result;
12231   return jresult;
12232 }
12233
12234
12235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12236   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12237
12238   arg1 = (Dali::Matrix3 *)jarg1;
12239   {
12240     try {
12241       delete arg1;
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (...) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12253       };
12254     }
12255   }
12256 }
12257
12258
12259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12260   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12261
12262   arg1 = (Dali::Matrix3 *)jarg1;
12263   {
12264     try {
12265       (arg1)->SetIdentity();
12266     } catch (std::out_of_range& e) {
12267       {
12268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12269       };
12270     } catch (std::exception& e) {
12271       {
12272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12273       };
12274     } catch (...) {
12275       {
12276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12277       };
12278     }
12279   }
12280 }
12281
12282
12283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12284   void * jresult ;
12285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12286   float *result = 0 ;
12287
12288   arg1 = (Dali::Matrix3 *)jarg1;
12289   {
12290     try {
12291       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12303       };
12304     }
12305   }
12306   jresult = (void *)result;
12307   return jresult;
12308 }
12309
12310
12311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12312   unsigned int jresult ;
12313   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12314   bool result;
12315
12316   arg1 = (Dali::Matrix3 *)jarg1;
12317   {
12318     try {
12319       result = (bool)(arg1)->Invert();
12320     } catch (std::out_of_range& e) {
12321       {
12322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12323       };
12324     } catch (std::exception& e) {
12325       {
12326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (...) {
12329       {
12330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12331       };
12332     }
12333   }
12334   jresult = result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12340   unsigned int jresult ;
12341   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12342   bool result;
12343
12344   arg1 = (Dali::Matrix3 *)jarg1;
12345   {
12346     try {
12347       result = (bool)(arg1)->Transpose();
12348     } catch (std::out_of_range& e) {
12349       {
12350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12351       };
12352     } catch (std::exception& e) {
12353       {
12354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12355       };
12356     } catch (...) {
12357       {
12358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12359       };
12360     }
12361   }
12362   jresult = result;
12363   return jresult;
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12368   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12369   float arg2 ;
12370
12371   arg1 = (Dali::Matrix3 *)jarg1;
12372   arg2 = (float)jarg2;
12373   {
12374     try {
12375       (arg1)->Scale(arg2);
12376     } catch (std::out_of_range& e) {
12377       {
12378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12379       };
12380     } catch (std::exception& e) {
12381       {
12382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12383       };
12384     } catch (...) {
12385       {
12386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12387       };
12388     }
12389   }
12390 }
12391
12392
12393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12394   float jresult ;
12395   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12396   float result;
12397
12398   arg1 = (Dali::Matrix3 *)jarg1;
12399   {
12400     try {
12401       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12402     } catch (std::out_of_range& e) {
12403       {
12404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12405       };
12406     } catch (std::exception& e) {
12407       {
12408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12413       };
12414     }
12415   }
12416   jresult = result;
12417   return jresult;
12418 }
12419
12420
12421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12422   unsigned int jresult ;
12423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12424   bool result;
12425
12426   arg1 = (Dali::Matrix3 *)jarg1;
12427   {
12428     try {
12429       result = (bool)(arg1)->ScaledInverseTranspose();
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12437       };
12438     } catch (...) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12441       };
12442     }
12443   }
12444   jresult = result;
12445   return jresult;
12446 }
12447
12448
12449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12450   Dali::Matrix3 *arg1 = 0 ;
12451   Dali::Matrix3 *arg2 = 0 ;
12452   Dali::Matrix3 *arg3 = 0 ;
12453
12454   arg1 = (Dali::Matrix3 *)jarg1;
12455   if (!arg1) {
12456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12457     return ;
12458   }
12459   arg2 = (Dali::Matrix3 *)jarg2;
12460   if (!arg2) {
12461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12462     return ;
12463   }
12464   arg3 = (Dali::Matrix3 *)jarg3;
12465   if (!arg3) {
12466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12467     return ;
12468   }
12469   {
12470     try {
12471       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12472     } catch (std::out_of_range& e) {
12473       {
12474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12475       };
12476     } catch (std::exception& e) {
12477       {
12478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12483       };
12484     }
12485   }
12486 }
12487
12488
12489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12490   float jresult ;
12491   float arg1 ;
12492   float arg2 ;
12493   float result;
12494
12495   arg1 = (float)jarg1;
12496   arg2 = (float)jarg2;
12497   {
12498     try {
12499       result = (float)Dali::Random::Range(arg1,arg2);
12500     } catch (std::out_of_range& e) {
12501       {
12502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (std::exception& e) {
12505       {
12506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12511       };
12512     }
12513   }
12514   jresult = result;
12515   return jresult;
12516 }
12517
12518
12519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12520   void * jresult ;
12521   Dali::Vector4 result;
12522
12523   {
12524     try {
12525       result = Dali::Random::Axis();
12526     } catch (std::out_of_range& e) {
12527       {
12528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12529       };
12530     } catch (std::exception& e) {
12531       {
12532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12533       };
12534     } catch (...) {
12535       {
12536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12537       };
12538     }
12539   }
12540   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12541   return jresult;
12542 }
12543
12544
12545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12546   void * jresult ;
12547   Dali::AngleAxis *result = 0 ;
12548
12549   {
12550     try {
12551       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12552     } catch (std::out_of_range& e) {
12553       {
12554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12555       };
12556     } catch (std::exception& e) {
12557       {
12558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12563       };
12564     }
12565   }
12566   jresult = (void *)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12572   void * jresult ;
12573   Dali::Radian arg1 ;
12574   Dali::Vector3 *arg2 = 0 ;
12575   Dali::Radian *argp1 ;
12576   Dali::AngleAxis *result = 0 ;
12577
12578   argp1 = (Dali::Radian *)jarg1;
12579   if (!argp1) {
12580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12581     return 0;
12582   }
12583   arg1 = *argp1;
12584   arg2 = (Dali::Vector3 *)jarg2;
12585   if (!arg2) {
12586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12587     return 0;
12588   }
12589   {
12590     try {
12591       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12592     } catch (std::out_of_range& e) {
12593       {
12594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12595       };
12596     } catch (std::exception& e) {
12597       {
12598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12599       };
12600     } catch (...) {
12601       {
12602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12603       };
12604     }
12605   }
12606   jresult = (void *)result;
12607   return jresult;
12608 }
12609
12610
12611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12612   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12613   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12614
12615   arg1 = (Dali::AngleAxis *)jarg1;
12616   arg2 = (Dali::Radian *)jarg2;
12617   if (arg1) (arg1)->angle = *arg2;
12618 }
12619
12620
12621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12622   void * jresult ;
12623   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12624   Dali::Radian *result = 0 ;
12625
12626   arg1 = (Dali::AngleAxis *)jarg1;
12627   result = (Dali::Radian *)& ((arg1)->angle);
12628   jresult = (void *)result;
12629   return jresult;
12630 }
12631
12632
12633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12634   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12635   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12636
12637   arg1 = (Dali::AngleAxis *)jarg1;
12638   arg2 = (Dali::Vector3 *)jarg2;
12639   if (arg1) (arg1)->axis = *arg2;
12640 }
12641
12642
12643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12644   void * jresult ;
12645   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12646   Dali::Vector3 *result = 0 ;
12647
12648   arg1 = (Dali::AngleAxis *)jarg1;
12649   result = (Dali::Vector3 *)& ((arg1)->axis);
12650   jresult = (void *)result;
12651   return jresult;
12652 }
12653
12654
12655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12656   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12657
12658   arg1 = (Dali::AngleAxis *)jarg1;
12659   {
12660     try {
12661       delete arg1;
12662     } catch (std::out_of_range& e) {
12663       {
12664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12665       };
12666     } catch (std::exception& e) {
12667       {
12668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12669       };
12670     } catch (...) {
12671       {
12672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12673       };
12674     }
12675   }
12676 }
12677
12678
12679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12680   unsigned int jresult ;
12681   Dali::AngleAxis *arg1 = 0 ;
12682   Dali::AngleAxis *arg2 = 0 ;
12683   bool result;
12684
12685   arg1 = (Dali::AngleAxis *)jarg1;
12686   if (!arg1) {
12687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12688     return 0;
12689   }
12690   arg2 = (Dali::AngleAxis *)jarg2;
12691   if (!arg2) {
12692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12693     return 0;
12694   }
12695   {
12696     try {
12697       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12698     } catch (std::out_of_range& e) {
12699       {
12700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12701       };
12702     } catch (std::exception& e) {
12703       {
12704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12705       };
12706     } catch (...) {
12707       {
12708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12709       };
12710     }
12711   }
12712   jresult = result;
12713   return jresult;
12714 }
12715
12716
12717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12718   unsigned int jresult ;
12719   unsigned int arg1 ;
12720   unsigned int result;
12721
12722   arg1 = (unsigned int)jarg1;
12723   {
12724     try {
12725       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12726     } catch (std::out_of_range& e) {
12727       {
12728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12729       };
12730     } catch (std::exception& e) {
12731       {
12732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (...) {
12735       {
12736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12737       };
12738     }
12739   }
12740   jresult = result;
12741   return jresult;
12742 }
12743
12744
12745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12746   unsigned int jresult ;
12747   unsigned int arg1 ;
12748   bool result;
12749
12750   arg1 = (unsigned int)jarg1;
12751   {
12752     try {
12753       result = (bool)Dali::IsPowerOfTwo(arg1);
12754     } catch (std::out_of_range& e) {
12755       {
12756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12757       };
12758     } catch (std::exception& e) {
12759       {
12760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12761       };
12762     } catch (...) {
12763       {
12764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12765       };
12766     }
12767   }
12768   jresult = result;
12769   return jresult;
12770 }
12771
12772
12773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12774   float jresult ;
12775   float arg1 ;
12776   float arg2 ;
12777   float result;
12778
12779   arg1 = (float)jarg1;
12780   arg2 = (float)jarg2;
12781   {
12782     try {
12783       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12784     } catch (std::out_of_range& e) {
12785       {
12786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12787       };
12788     } catch (std::exception& e) {
12789       {
12790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12791       };
12792     } catch (...) {
12793       {
12794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12795       };
12796     }
12797   }
12798   jresult = result;
12799   return jresult;
12800 }
12801
12802
12803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12804   unsigned int jresult ;
12805   float arg1 ;
12806   bool result;
12807
12808   arg1 = (float)jarg1;
12809   {
12810     try {
12811       result = (bool)Dali::EqualsZero(arg1);
12812     } catch (std::out_of_range& e) {
12813       {
12814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (std::exception& e) {
12817       {
12818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826   jresult = result;
12827   return jresult;
12828 }
12829
12830
12831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12832   unsigned int jresult ;
12833   float arg1 ;
12834   float arg2 ;
12835   bool result;
12836
12837   arg1 = (float)jarg1;
12838   arg2 = (float)jarg2;
12839   {
12840     try {
12841       result = (bool)Dali::Equals(arg1,arg2);
12842     } catch (std::out_of_range& e) {
12843       {
12844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12845       };
12846     } catch (std::exception& e) {
12847       {
12848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12849       };
12850     } catch (...) {
12851       {
12852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12853       };
12854     }
12855   }
12856   jresult = result;
12857   return jresult;
12858 }
12859
12860
12861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12862   unsigned int jresult ;
12863   float arg1 ;
12864   float arg2 ;
12865   float arg3 ;
12866   bool result;
12867
12868   arg1 = (float)jarg1;
12869   arg2 = (float)jarg2;
12870   arg3 = (float)jarg3;
12871   {
12872     try {
12873       result = (bool)Dali::Equals(arg1,arg2,arg3);
12874     } catch (std::out_of_range& e) {
12875       {
12876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12877       };
12878     } catch (std::exception& e) {
12879       {
12880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12881       };
12882     } catch (...) {
12883       {
12884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12885       };
12886     }
12887   }
12888   jresult = result;
12889   return jresult;
12890 }
12891
12892
12893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12894   float jresult ;
12895   float arg1 ;
12896   int arg2 ;
12897   float result;
12898
12899   arg1 = (float)jarg1;
12900   arg2 = (int)jarg2;
12901   {
12902     try {
12903       result = (float)Dali::Round(arg1,arg2);
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12911       };
12912     } catch (...) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12915       };
12916     }
12917   }
12918   jresult = result;
12919   return jresult;
12920 }
12921
12922
12923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12924   float jresult ;
12925   float arg1 ;
12926   float arg2 ;
12927   float arg3 ;
12928   float result;
12929
12930   arg1 = (float)jarg1;
12931   arg2 = (float)jarg2;
12932   arg3 = (float)jarg3;
12933   {
12934     try {
12935       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12936     } catch (std::out_of_range& e) {
12937       {
12938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (std::exception& e) {
12941       {
12942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (...) {
12945       {
12946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12947       };
12948     }
12949   }
12950   jresult = result;
12951   return jresult;
12952 }
12953
12954
12955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12956   float jresult ;
12957   float arg1 ;
12958   float arg2 ;
12959   float arg3 ;
12960   float arg4 ;
12961   float result;
12962
12963   arg1 = (float)jarg1;
12964   arg2 = (float)jarg2;
12965   arg3 = (float)jarg3;
12966   arg4 = (float)jarg4;
12967   {
12968     try {
12969       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12970     } catch (std::out_of_range& e) {
12971       {
12972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12973       };
12974     } catch (std::exception& e) {
12975       {
12976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12977       };
12978     } catch (...) {
12979       {
12980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12981       };
12982     }
12983   }
12984   jresult = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12990   int jresult ;
12991   int result;
12992
12993   result = (int)(int)Dali::Property::INVALID_INDEX;
12994   jresult = result;
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
13000   int jresult ;
13001   int result;
13002
13003   result = (int)(int)Dali::Property::INVALID_KEY;
13004   jresult = result;
13005   return jresult;
13006 }
13007
13008
13009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13010   int jresult ;
13011   int result;
13012
13013   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13014   jresult = result;
13015   return jresult;
13016 }
13017
13018
13019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13020   void * jresult ;
13021   Dali::Handle *arg1 = 0 ;
13022   Dali::Property::Index arg2 ;
13023   Dali::Property *result = 0 ;
13024
13025   arg1 = (Dali::Handle *)jarg1;
13026   if (!arg1) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13028     return 0;
13029   }
13030   arg2 = (Dali::Property::Index)jarg2;
13031   {
13032     try {
13033       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13034     } catch (std::out_of_range& e) {
13035       {
13036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13037       };
13038     } catch (std::exception& e) {
13039       {
13040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13041       };
13042     } catch (...) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13045       };
13046     }
13047   }
13048   jresult = (void *)result;
13049   return jresult;
13050 }
13051
13052
13053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13054   void * jresult ;
13055   Dali::Handle *arg1 = 0 ;
13056   Dali::Property::Index arg2 ;
13057   int arg3 ;
13058   Dali::Property *result = 0 ;
13059
13060   arg1 = (Dali::Handle *)jarg1;
13061   if (!arg1) {
13062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13063     return 0;
13064   }
13065   arg2 = (Dali::Property::Index)jarg2;
13066   arg3 = (int)jarg3;
13067   {
13068     try {
13069       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084   jresult = (void *)result;
13085   return jresult;
13086 }
13087
13088
13089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13090   void * jresult ;
13091   Dali::Handle *arg1 = 0 ;
13092   std::string *arg2 = 0 ;
13093   Dali::Property *result = 0 ;
13094
13095   arg1 = (Dali::Handle *)jarg1;
13096   if (!arg1) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13098     return 0;
13099   }
13100   if (!jarg2) {
13101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13102     return 0;
13103   }
13104   std::string arg2_str(jarg2);
13105   arg2 = &arg2_str;
13106   {
13107     try {
13108       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (...) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13120       };
13121     }
13122   }
13123   jresult = (void *)result;
13124
13125   //argout typemap for const std::string&
13126
13127   return jresult;
13128 }
13129
13130
13131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13132   void * jresult ;
13133   Dali::Handle *arg1 = 0 ;
13134   std::string *arg2 = 0 ;
13135   int arg3 ;
13136   Dali::Property *result = 0 ;
13137
13138   arg1 = (Dali::Handle *)jarg1;
13139   if (!arg1) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13141     return 0;
13142   }
13143   if (!jarg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13145     return 0;
13146   }
13147   std::string arg2_str(jarg2);
13148   arg2 = &arg2_str;
13149   arg3 = (int)jarg3;
13150   {
13151     try {
13152       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13153     } catch (std::out_of_range& e) {
13154       {
13155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13156       };
13157     } catch (std::exception& e) {
13158       {
13159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13164       };
13165     }
13166   }
13167   jresult = (void *)result;
13168
13169   //argout typemap for const std::string&
13170
13171   return jresult;
13172 }
13173
13174
13175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177
13178   arg1 = (Dali::Property *)jarg1;
13179   {
13180     try {
13181       delete arg1;
13182     } catch (std::out_of_range& e) {
13183       {
13184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13185       };
13186     } catch (std::exception& e) {
13187       {
13188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13189       };
13190     } catch (...) {
13191       {
13192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13193       };
13194     }
13195   }
13196 }
13197
13198
13199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13200   Dali::Property *arg1 = (Dali::Property *) 0 ;
13201   Dali::Handle *arg2 = 0 ;
13202
13203   arg1 = (Dali::Property *)jarg1;
13204   arg2 = (Dali::Handle *)jarg2;
13205   if (!arg2) {
13206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13207     return ;
13208   }
13209   if (arg1) (arg1)->object = *arg2;
13210 }
13211
13212
13213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13214   void * jresult ;
13215   Dali::Property *arg1 = (Dali::Property *) 0 ;
13216   Dali::Handle *result = 0 ;
13217
13218   arg1 = (Dali::Property *)jarg1;
13219   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13220   jresult = (void *)result;
13221   return jresult;
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13226   Dali::Property *arg1 = (Dali::Property *) 0 ;
13227   Dali::Property::Index arg2 ;
13228
13229   arg1 = (Dali::Property *)jarg1;
13230   arg2 = (Dali::Property::Index)jarg2;
13231   if (arg1) (arg1)->propertyIndex = arg2;
13232 }
13233
13234
13235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13236   int jresult ;
13237   Dali::Property *arg1 = (Dali::Property *) 0 ;
13238   Dali::Property::Index result;
13239
13240   arg1 = (Dali::Property *)jarg1;
13241   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13242   jresult = result;
13243   return jresult;
13244 }
13245
13246
13247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13248   Dali::Property *arg1 = (Dali::Property *) 0 ;
13249   int arg2 ;
13250
13251   arg1 = (Dali::Property *)jarg1;
13252   arg2 = (int)jarg2;
13253   if (arg1) (arg1)->componentIndex = arg2;
13254 }
13255
13256
13257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13258   int jresult ;
13259   Dali::Property *arg1 = (Dali::Property *) 0 ;
13260   int result;
13261
13262   arg1 = (Dali::Property *)jarg1;
13263   result = (int) ((arg1)->componentIndex);
13264   jresult = result;
13265   return jresult;
13266 }
13267
13268
13269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13270   void * jresult ;
13271   Dali::Property::Array *result = 0 ;
13272
13273   {
13274     try {
13275       result = (Dali::Property::Array *)new Dali::Property::Array();
13276     } catch (std::out_of_range& e) {
13277       {
13278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13279       };
13280     } catch (std::exception& e) {
13281       {
13282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13283       };
13284     } catch (...) {
13285       {
13286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13287       };
13288     }
13289   }
13290   jresult = (void *)result;
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13296   void * jresult ;
13297   Dali::Property::Array *arg1 = 0 ;
13298   Dali::Property::Array *result = 0 ;
13299
13300   arg1 = (Dali::Property::Array *)jarg1;
13301   if (!arg1) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13303     return 0;
13304   }
13305   {
13306     try {
13307       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13308     } catch (std::out_of_range& e) {
13309       {
13310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13311       };
13312     } catch (std::exception& e) {
13313       {
13314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13315       };
13316     } catch (...) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13319       };
13320     }
13321   }
13322   jresult = (void *)result;
13323   return jresult;
13324 }
13325
13326
13327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13328   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13329
13330   arg1 = (Dali::Property::Array *)jarg1;
13331   {
13332     try {
13333       delete arg1;
13334     } catch (std::out_of_range& e) {
13335       {
13336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13337       };
13338     } catch (std::exception& e) {
13339       {
13340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13345       };
13346     }
13347   }
13348 }
13349
13350
13351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13352   unsigned long jresult ;
13353   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13354   Dali::Property::Array::SizeType result;
13355
13356   arg1 = (Dali::Property::Array *)jarg1;
13357   {
13358     try {
13359       result = ((Dali::Property::Array const *)arg1)->Size();
13360     } catch (std::out_of_range& e) {
13361       {
13362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13363       };
13364     } catch (std::exception& e) {
13365       {
13366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13367       };
13368     } catch (...) {
13369       {
13370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13371       };
13372     }
13373   }
13374   jresult = (unsigned long)result;
13375   return jresult;
13376 }
13377
13378
13379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13380   unsigned long jresult ;
13381   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13382   Dali::Property::Array::SizeType result;
13383
13384   arg1 = (Dali::Property::Array *)jarg1;
13385   {
13386     try {
13387       result = ((Dali::Property::Array const *)arg1)->Count();
13388     } catch (std::out_of_range& e) {
13389       {
13390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13391       };
13392     } catch (std::exception& e) {
13393       {
13394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13395       };
13396     } catch (...) {
13397       {
13398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13399       };
13400     }
13401   }
13402   jresult = (unsigned long)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13408   unsigned int jresult ;
13409   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13410   bool result;
13411
13412   arg1 = (Dali::Property::Array *)jarg1;
13413   {
13414     try {
13415       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13416     } catch (std::out_of_range& e) {
13417       {
13418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (std::exception& e) {
13421       {
13422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430   jresult = result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13436   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13437
13438   arg1 = (Dali::Property::Array *)jarg1;
13439   {
13440     try {
13441       (arg1)->Clear();
13442     } catch (std::out_of_range& e) {
13443       {
13444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13445       };
13446     } catch (std::exception& e) {
13447       {
13448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13453       };
13454     }
13455   }
13456 }
13457
13458
13459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13460   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13461   Dali::Property::Array::SizeType arg2 ;
13462
13463   arg1 = (Dali::Property::Array *)jarg1;
13464   arg2 = (Dali::Property::Array::SizeType)jarg2;
13465   {
13466     try {
13467       (arg1)->Reserve(arg2);
13468     } catch (std::out_of_range& e) {
13469       {
13470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13471       };
13472     } catch (std::exception& e) {
13473       {
13474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13475       };
13476     } catch (...) {
13477       {
13478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13479       };
13480     }
13481   }
13482 }
13483
13484
13485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13486   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13487   Dali::Property::Array::SizeType arg2 ;
13488
13489   arg1 = (Dali::Property::Array *)jarg1;
13490   arg2 = (Dali::Property::Array::SizeType)jarg2;
13491   {
13492     try {
13493       (arg1)->Resize(arg2);
13494     } catch (std::out_of_range& e) {
13495       {
13496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13497       };
13498     } catch (std::exception& e) {
13499       {
13500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13501       };
13502     } catch (...) {
13503       {
13504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13505       };
13506     }
13507   }
13508 }
13509
13510
13511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13512   unsigned long jresult ;
13513   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13514   Dali::Property::Array::SizeType result;
13515
13516   arg1 = (Dali::Property::Array *)jarg1;
13517   {
13518     try {
13519       result = (arg1)->Capacity();
13520     } catch (std::out_of_range& e) {
13521       {
13522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13523       };
13524     } catch (std::exception& e) {
13525       {
13526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13527       };
13528     } catch (...) {
13529       {
13530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13531       };
13532     }
13533   }
13534   jresult = (unsigned long)result;
13535   return jresult;
13536 }
13537
13538
13539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13540   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13541   Dali::Property::Value *arg2 = 0 ;
13542
13543   arg1 = (Dali::Property::Array *)jarg1;
13544   arg2 = (Dali::Property::Value *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13547     return ;
13548   }
13549   {
13550     try {
13551       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13552     } catch (std::out_of_range& e) {
13553       {
13554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13555       };
13556     } catch (std::exception& e) {
13557       {
13558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13559       };
13560     } catch (...) {
13561       {
13562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13563       };
13564     }
13565   }
13566 }
13567
13568
13569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13570   void * jresult ;
13571   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13572   Dali::Property::Value *arg2 = 0 ;
13573   Dali::Property::Array *result = 0 ;
13574
13575   arg1 = (Dali::Property::Array *)jarg1;
13576   arg2 = (Dali::Property::Value *)jarg2;
13577   if (!arg2) {
13578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13579     return 0;
13580   }
13581   {
13582     try {
13583       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13584     } catch (std::out_of_range& e) {
13585       {
13586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13587       };
13588     } catch (std::exception& e) {
13589       {
13590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13591       };
13592     } catch (...) {
13593       {
13594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13595       };
13596     }
13597   }
13598   jresult = (void *)result;
13599   return jresult;
13600 }
13601
13602
13603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13604   void * jresult ;
13605   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13606   Dali::Property::Array::SizeType arg2 ;
13607   Dali::Property::Value *result = 0 ;
13608
13609   arg1 = (Dali::Property::Array *)jarg1;
13610   arg2 = (Dali::Property::Array::SizeType)jarg2;
13611   {
13612     try {
13613       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13614     } catch (std::out_of_range& e) {
13615       {
13616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (std::exception& e) {
13619       {
13620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13634   void * jresult ;
13635   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13636   Dali::Property::Array::SizeType arg2 ;
13637   Dali::Property::Value *result = 0 ;
13638
13639   arg1 = (Dali::Property::Array *)jarg1;
13640   arg2 = (Dali::Property::Array::SizeType)jarg2;
13641   {
13642     try {
13643       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (...) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13655       };
13656     }
13657   }
13658   jresult = (void *)result;
13659   return jresult;
13660 }
13661
13662
13663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13664   void * jresult ;
13665   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13666   Dali::Property::Array *arg2 = 0 ;
13667   Dali::Property::Array *result = 0 ;
13668
13669   arg1 = (Dali::Property::Array *)jarg1;
13670   arg2 = (Dali::Property::Array *)jarg2;
13671   if (!arg2) {
13672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13673     return 0;
13674   }
13675   {
13676     try {
13677       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13678     } catch (std::out_of_range& e) {
13679       {
13680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13681       };
13682     } catch (std::exception& e) {
13683       {
13684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13685       };
13686     } catch (...) {
13687       {
13688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13689       };
13690     }
13691   }
13692   jresult = (void *)result;
13693   return jresult;
13694 }
13695
13696
13697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13698   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13699   enum Dali::Property::Key::Type arg2 ;
13700
13701   arg1 = (Dali::Property::Key *)jarg1;
13702   arg2 = (enum Dali::Property::Key::Type)jarg2;
13703   if (arg1) (arg1)->type = arg2;
13704 }
13705
13706
13707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13708   int jresult ;
13709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13710   enum Dali::Property::Key::Type result;
13711
13712   arg1 = (Dali::Property::Key *)jarg1;
13713   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13714   jresult = (int)result;
13715   return jresult;
13716 }
13717
13718
13719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13720   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13721   Dali::Property::Index arg2 ;
13722
13723   arg1 = (Dali::Property::Key *)jarg1;
13724   arg2 = (Dali::Property::Index)jarg2;
13725   if (arg1) (arg1)->indexKey = arg2;
13726 }
13727
13728
13729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13730   int jresult ;
13731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13732   Dali::Property::Index result;
13733
13734   arg1 = (Dali::Property::Key *)jarg1;
13735   result = (Dali::Property::Index) ((arg1)->indexKey);
13736   jresult = result;
13737   return jresult;
13738 }
13739
13740
13741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13743   std::string *arg2 = 0 ;
13744
13745   arg1 = (Dali::Property::Key *)jarg1;
13746   if (!jarg2) {
13747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13748     return ;
13749   }
13750   std::string arg2_str(jarg2);
13751   arg2 = &arg2_str;
13752   if (arg1) (arg1)->stringKey = *arg2;
13753
13754   //argout typemap for const std::string&
13755
13756 }
13757
13758
13759 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13760   char * jresult ;
13761   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13762   std::string *result = 0 ;
13763
13764   arg1 = (Dali::Property::Key *)jarg1;
13765   result = (std::string *) & ((arg1)->stringKey);
13766   jresult = SWIG_csharp_string_callback(result->c_str());
13767   return jresult;
13768 }
13769
13770
13771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13772   void * jresult ;
13773   std::string *arg1 = 0 ;
13774   Dali::Property::Key *result = 0 ;
13775
13776   if (!jarg1) {
13777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13778     return 0;
13779   }
13780   std::string arg1_str(jarg1);
13781   arg1 = &arg1_str;
13782   {
13783     try {
13784       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13785     } catch (std::out_of_range& e) {
13786       {
13787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (std::exception& e) {
13790       {
13791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799   jresult = (void *)result;
13800
13801   //argout typemap for const std::string&
13802
13803   return jresult;
13804 }
13805
13806
13807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13808   void * jresult ;
13809   Dali::Property::Index arg1 ;
13810   Dali::Property::Key *result = 0 ;
13811
13812   arg1 = (Dali::Property::Index)jarg1;
13813   {
13814     try {
13815       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13816     } catch (std::out_of_range& e) {
13817       {
13818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (std::exception& e) {
13821       {
13822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830   jresult = (void *)result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13836   unsigned int jresult ;
13837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13838   std::string *arg2 = 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Property::Key *)jarg1;
13842   if (!jarg2) {
13843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13844     return 0;
13845   }
13846   std::string arg2_str(jarg2);
13847   arg2 = &arg2_str;
13848   {
13849     try {
13850       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13851     } catch (std::out_of_range& e) {
13852       {
13853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (std::exception& e) {
13856       {
13857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865   jresult = result;
13866
13867   //argout typemap for const std::string&
13868
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13874   unsigned int jresult ;
13875   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13876   Dali::Property::Index arg2 ;
13877   bool result;
13878
13879   arg1 = (Dali::Property::Key *)jarg1;
13880   arg2 = (Dali::Property::Index)jarg2;
13881   {
13882     try {
13883       result = (bool)(arg1)->operator ==(arg2);
13884     } catch (std::out_of_range& e) {
13885       {
13886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (std::exception& e) {
13889       {
13890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13895       };
13896     }
13897   }
13898   jresult = result;
13899   return jresult;
13900 }
13901
13902
13903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13904   unsigned int jresult ;
13905   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13906   Dali::Property::Key *arg2 = 0 ;
13907   bool result;
13908
13909   arg1 = (Dali::Property::Key *)jarg1;
13910   arg2 = (Dali::Property::Key *)jarg2;
13911   if (!arg2) {
13912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13913     return 0;
13914   }
13915   {
13916     try {
13917       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13918     } catch (std::out_of_range& e) {
13919       {
13920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (std::exception& e) {
13923       {
13924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932   jresult = result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13938   unsigned int jresult ;
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940   std::string *arg2 = 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Property::Key *)jarg1;
13944   if (!jarg2) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13946     return 0;
13947   }
13948   std::string arg2_str(jarg2);
13949   arg2 = &arg2_str;
13950   {
13951     try {
13952       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13953     } catch (std::out_of_range& e) {
13954       {
13955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13956       };
13957     } catch (std::exception& e) {
13958       {
13959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13960       };
13961     } catch (...) {
13962       {
13963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13964       };
13965     }
13966   }
13967   jresult = result;
13968
13969   //argout typemap for const std::string&
13970
13971   return jresult;
13972 }
13973
13974
13975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13976   unsigned int jresult ;
13977   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13978   Dali::Property::Index arg2 ;
13979   bool result;
13980
13981   arg1 = (Dali::Property::Key *)jarg1;
13982   arg2 = (Dali::Property::Index)jarg2;
13983   {
13984     try {
13985       result = (bool)(arg1)->operator !=(arg2);
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (...) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13997       };
13998     }
13999   }
14000   jresult = result;
14001   return jresult;
14002 }
14003
14004
14005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14006   unsigned int jresult ;
14007   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14008   Dali::Property::Key *arg2 = 0 ;
14009   bool result;
14010
14011   arg1 = (Dali::Property::Key *)jarg1;
14012   arg2 = (Dali::Property::Key *)jarg2;
14013   if (!arg2) {
14014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14015     return 0;
14016   }
14017   {
14018     try {
14019       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14020     } catch (std::out_of_range& e) {
14021       {
14022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14023       };
14024     } catch (std::exception& e) {
14025       {
14026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (...) {
14029       {
14030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14031       };
14032     }
14033   }
14034   jresult = result;
14035   return jresult;
14036 }
14037
14038
14039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14040   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14041
14042   arg1 = (Dali::Property::Key *)jarg1;
14043   {
14044     try {
14045       delete arg1;
14046     } catch (std::out_of_range& e) {
14047       {
14048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14049       };
14050     } catch (std::exception& e) {
14051       {
14052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14057       };
14058     }
14059   }
14060 }
14061
14062
14063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14064   void * jresult ;
14065   Dali::Property::Map *result = 0 ;
14066
14067   {
14068     try {
14069       result = (Dali::Property::Map *)new Dali::Property::Map();
14070     } catch (std::out_of_range& e) {
14071       {
14072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14073       };
14074     } catch (std::exception& e) {
14075       {
14076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14081       };
14082     }
14083   }
14084   jresult = (void *)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14090   void * jresult ;
14091   Dali::Property::Map *arg1 = 0 ;
14092   Dali::Property::Map *result = 0 ;
14093
14094   arg1 = (Dali::Property::Map *)jarg1;
14095   if (!arg1) {
14096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14097     return 0;
14098   }
14099   {
14100     try {
14101       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14102     } catch (std::out_of_range& e) {
14103       {
14104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14105       };
14106     } catch (std::exception& e) {
14107       {
14108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14109       };
14110     } catch (...) {
14111       {
14112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14113       };
14114     }
14115   }
14116   jresult = (void *)result;
14117   return jresult;
14118 }
14119
14120
14121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14122   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14123
14124   arg1 = (Dali::Property::Map *)jarg1;
14125   {
14126     try {
14127       delete arg1;
14128     } catch (std::out_of_range& e) {
14129       {
14130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14131       };
14132     } catch (std::exception& e) {
14133       {
14134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14135       };
14136     } catch (...) {
14137       {
14138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14139       };
14140     }
14141   }
14142 }
14143
14144
14145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14146   unsigned long jresult ;
14147   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14148   Dali::Property::Map::SizeType result;
14149
14150   arg1 = (Dali::Property::Map *)jarg1;
14151   {
14152     try {
14153       result = ((Dali::Property::Map const *)arg1)->Count();
14154     } catch (std::out_of_range& e) {
14155       {
14156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14157       };
14158     } catch (std::exception& e) {
14159       {
14160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14161       };
14162     } catch (...) {
14163       {
14164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14165       };
14166     }
14167   }
14168   jresult = (unsigned long)result;
14169   return jresult;
14170 }
14171
14172
14173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14174   unsigned int jresult ;
14175   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14176   bool result;
14177
14178   arg1 = (Dali::Property::Map *)jarg1;
14179   {
14180     try {
14181       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14182     } catch (std::out_of_range& e) {
14183       {
14184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14185       };
14186     } catch (std::exception& e) {
14187       {
14188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14189       };
14190     } catch (...) {
14191       {
14192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14193       };
14194     }
14195   }
14196   jresult = result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14202   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14203   char *arg2 = (char *) 0 ;
14204   Dali::Property::Value *arg3 = 0 ;
14205
14206   arg1 = (Dali::Property::Map *)jarg1;
14207   arg2 = (char *)jarg2;
14208   arg3 = (Dali::Property::Value *)jarg3;
14209   if (!arg3) {
14210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14211     return ;
14212   }
14213   {
14214     try {
14215       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14216     } catch (std::out_of_range& e) {
14217       {
14218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14219       };
14220     } catch (std::exception& e) {
14221       {
14222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14223       };
14224     } catch (...) {
14225       {
14226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14227       };
14228     }
14229   }
14230 }
14231
14232
14233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14235   Dali::Property::Index arg2 ;
14236   Dali::Property::Value *arg3 = 0 ;
14237
14238   arg1 = (Dali::Property::Map *)jarg1;
14239   arg2 = (Dali::Property::Index)jarg2;
14240   arg3 = (Dali::Property::Value *)jarg3;
14241   if (!arg3) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14243     return ;
14244   }
14245   {
14246     try {
14247       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14259       };
14260     }
14261   }
14262 }
14263
14264
14265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14266   void * jresult ;
14267   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14268   char *arg2 = (char *) 0 ;
14269   Dali::Property::Value *arg3 = 0 ;
14270   Dali::Property::Map *result = 0 ;
14271
14272   arg1 = (Dali::Property::Map *)jarg1;
14273   arg2 = (char *)jarg2;
14274   arg3 = (Dali::Property::Value *)jarg3;
14275   if (!arg3) {
14276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14277     return 0;
14278   }
14279   {
14280     try {
14281       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14282     } catch (std::out_of_range& e) {
14283       {
14284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (std::exception& e) {
14287       {
14288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14289       };
14290     } catch (...) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14293       };
14294     }
14295   }
14296   jresult = (void *)result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14302   void * jresult ;
14303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14304   Dali::Property::Index arg2 ;
14305   Dali::Property::Value *arg3 = 0 ;
14306   Dali::Property::Map *result = 0 ;
14307
14308   arg1 = (Dali::Property::Map *)jarg1;
14309   arg2 = (Dali::Property::Index)jarg2;
14310   arg3 = (Dali::Property::Value *)jarg3;
14311   if (!arg3) {
14312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14313     return 0;
14314   }
14315   {
14316     try {
14317       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332   jresult = (void *)result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14338   void * jresult ;
14339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14340   Dali::Property::Map::SizeType arg2 ;
14341   Dali::Property::Value *result = 0 ;
14342
14343   arg1 = (Dali::Property::Map *)jarg1;
14344   arg2 = (Dali::Property::Map::SizeType)jarg2;
14345   {
14346     try {
14347       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (...) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14359       };
14360     }
14361   }
14362   jresult = (void *)result;
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14368   char * jresult ;
14369   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14370   Dali::Property::Map::SizeType arg2 ;
14371   std::string *result = 0 ;
14372
14373   arg1 = (Dali::Property::Map *)jarg1;
14374   arg2 = (Dali::Property::Map::SizeType)jarg2;
14375   {
14376     try {
14377       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (...) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14389       };
14390     }
14391   }
14392   jresult = SWIG_csharp_string_callback(result->c_str());
14393   return jresult;
14394 }
14395
14396
14397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14398   void * jresult ;
14399   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14400   Dali::Property::Map::SizeType arg2 ;
14401   SwigValueWrapper< Dali::Property::Key > result;
14402
14403   arg1 = (Dali::Property::Map *)jarg1;
14404   arg2 = (Dali::Property::Map::SizeType)jarg2;
14405   {
14406     try {
14407       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14408     } catch (std::out_of_range& e) {
14409       {
14410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14411       };
14412     } catch (std::exception& e) {
14413       {
14414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14415       };
14416     } catch (...) {
14417       {
14418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14419       };
14420     }
14421   }
14422   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14428   void * jresult ;
14429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14430   Dali::Property::Map::SizeType arg2 ;
14431   StringValuePair *result = 0 ;
14432
14433   arg1 = (Dali::Property::Map *)jarg1;
14434   arg2 = (Dali::Property::Map::SizeType)jarg2;
14435   {
14436     try {
14437       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14438     } catch (std::out_of_range& e) {
14439       {
14440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (std::exception& e) {
14443       {
14444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (...) {
14447       {
14448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14449       };
14450     }
14451   }
14452   jresult = (void *)result;
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   char *arg2 = (char *) 0 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   arg2 = (char *)jarg2;
14465   {
14466     try {
14467       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14468     } catch (std::out_of_range& e) {
14469       {
14470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14471       };
14472     } catch (std::exception& e) {
14473       {
14474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14475       };
14476     } catch (...) {
14477       {
14478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14479       };
14480     }
14481   }
14482   jresult = (void *)result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14488   void * jresult ;
14489   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14490   Dali::Property::Index arg2 ;
14491   Dali::Property::Value *result = 0 ;
14492
14493   arg1 = (Dali::Property::Map *)jarg1;
14494   arg2 = (Dali::Property::Index)jarg2;
14495   {
14496     try {
14497       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14498     } catch (std::out_of_range& e) {
14499       {
14500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14501       };
14502     } catch (std::exception& e) {
14503       {
14504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14505       };
14506     } catch (...) {
14507       {
14508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14509       };
14510     }
14511   }
14512   jresult = (void *)result;
14513   return jresult;
14514 }
14515
14516
14517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14518   void * jresult ;
14519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14520   Dali::Property::Index arg2 ;
14521   std::string *arg3 = 0 ;
14522   Dali::Property::Value *result = 0 ;
14523
14524   arg1 = (Dali::Property::Map *)jarg1;
14525   arg2 = (Dali::Property::Index)jarg2;
14526   if (!jarg3) {
14527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14528     return 0;
14529   }
14530   std::string arg3_str(jarg3);
14531   arg3 = &arg3_str;
14532   {
14533     try {
14534       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14546       };
14547     }
14548   }
14549   jresult = (void *)result;
14550
14551   //argout typemap for const std::string&
14552
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14558   void * jresult ;
14559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14560   std::string *arg2 = 0 ;
14561   Dali::Property::Type arg3 ;
14562   Dali::Property::Value *result = 0 ;
14563
14564   arg1 = (Dali::Property::Map *)jarg1;
14565   if (!jarg2) {
14566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14567     return 0;
14568   }
14569   std::string arg2_str(jarg2);
14570   arg2 = &arg2_str;
14571   arg3 = (Dali::Property::Type)jarg3;
14572   {
14573     try {
14574       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14575     } catch (std::out_of_range& e) {
14576       {
14577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14578       };
14579     } catch (std::exception& e) {
14580       {
14581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14582       };
14583     } catch (...) {
14584       {
14585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14586       };
14587     }
14588   }
14589   jresult = (void *)result;
14590
14591   //argout typemap for const std::string&
14592
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14598   void * jresult ;
14599   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14600   Dali::Property::Index arg2 ;
14601   Dali::Property::Type arg3 ;
14602   Dali::Property::Value *result = 0 ;
14603
14604   arg1 = (Dali::Property::Map *)jarg1;
14605   arg2 = (Dali::Property::Index)jarg2;
14606   arg3 = (Dali::Property::Type)jarg3;
14607   {
14608     try {
14609       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14610     } catch (std::out_of_range& e) {
14611       {
14612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14613       };
14614     } catch (std::exception& e) {
14615       {
14616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14617       };
14618     } catch (...) {
14619       {
14620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14621       };
14622     }
14623   }
14624   jresult = (void *)result;
14625   return jresult;
14626 }
14627
14628
14629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14630   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14631
14632   arg1 = (Dali::Property::Map *)jarg1;
14633   {
14634     try {
14635       (arg1)->Clear();
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14643       };
14644     } catch (...) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14647       };
14648     }
14649   }
14650 }
14651
14652
14653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14654   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14655   Dali::Property::Map *arg2 = 0 ;
14656
14657   arg1 = (Dali::Property::Map *)jarg1;
14658   arg2 = (Dali::Property::Map *)jarg2;
14659   if (!arg2) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14661     return ;
14662   }
14663   {
14664     try {
14665       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14677       };
14678     }
14679   }
14680 }
14681
14682
14683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14684   void * jresult ;
14685   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14686   std::string *arg2 = 0 ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   arg1 = (Dali::Property::Map *)jarg1;
14690   if (!jarg2) {
14691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14692     return 0;
14693   }
14694   std::string arg2_str(jarg2);
14695   arg2 = &arg2_str;
14696   {
14697     try {
14698       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14699     } catch (std::out_of_range& e) {
14700       {
14701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14702       };
14703     } catch (std::exception& e) {
14704       {
14705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14706       };
14707     } catch (...) {
14708       {
14709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14710       };
14711     }
14712   }
14713   jresult = (void *)result;
14714
14715   //argout typemap for const std::string&
14716
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14722   void * jresult ;
14723   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14724   Dali::Property::Index arg2 ;
14725   Dali::Property::Value *result = 0 ;
14726
14727   arg1 = (Dali::Property::Map *)jarg1;
14728   arg2 = (Dali::Property::Index)jarg2;
14729   {
14730     try {
14731       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14732     } catch (std::out_of_range& e) {
14733       {
14734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14735       };
14736     } catch (std::exception& e) {
14737       {
14738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (...) {
14741       {
14742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14743       };
14744     }
14745   }
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14752   void * jresult ;
14753   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14754   Dali::Property::Map *arg2 = 0 ;
14755   Dali::Property::Map *result = 0 ;
14756
14757   arg1 = (Dali::Property::Map *)jarg1;
14758   arg2 = (Dali::Property::Map *)jarg2;
14759   if (!arg2) {
14760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14761     return 0;
14762   }
14763   {
14764     try {
14765       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14766     } catch (std::out_of_range& e) {
14767       {
14768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (std::exception& e) {
14771       {
14772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14786   void * jresult ;
14787   Dali::Property::Value *result = 0 ;
14788
14789   {
14790     try {
14791       result = (Dali::Property::Value *)new Dali::Property::Value();
14792     } catch (std::out_of_range& e) {
14793       {
14794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14795       };
14796     } catch (std::exception& e) {
14797       {
14798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14803       };
14804     }
14805   }
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14812   void * jresult ;
14813   bool arg1 ;
14814   Dali::Property::Value *result = 0 ;
14815
14816   arg1 = jarg1 ? true : false;
14817   {
14818     try {
14819       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14820     } catch (std::out_of_range& e) {
14821       {
14822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14823       };
14824     } catch (std::exception& e) {
14825       {
14826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14827       };
14828     } catch (...) {
14829       {
14830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14831       };
14832     }
14833   }
14834   jresult = (void *)result;
14835   return jresult;
14836 }
14837
14838
14839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14840   void * jresult ;
14841   int arg1 ;
14842   Dali::Property::Value *result = 0 ;
14843
14844   arg1 = (int)jarg1;
14845   {
14846     try {
14847       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14848     } catch (std::out_of_range& e) {
14849       {
14850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14851       };
14852     } catch (std::exception& e) {
14853       {
14854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14855       };
14856     } catch (...) {
14857       {
14858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14859       };
14860     }
14861   }
14862   jresult = (void *)result;
14863   return jresult;
14864 }
14865
14866
14867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14868   void * jresult ;
14869   float arg1 ;
14870   Dali::Property::Value *result = 0 ;
14871
14872   arg1 = (float)jarg1;
14873   {
14874     try {
14875       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14876     } catch (std::out_of_range& e) {
14877       {
14878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14879       };
14880     } catch (std::exception& e) {
14881       {
14882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14883       };
14884     } catch (...) {
14885       {
14886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14887       };
14888     }
14889   }
14890   jresult = (void *)result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14896   void * jresult ;
14897   Dali::Vector2 *arg1 = 0 ;
14898   Dali::Property::Value *result = 0 ;
14899
14900   arg1 = (Dali::Vector2 *)jarg1;
14901   if (!arg1) {
14902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14903     return 0;
14904   }
14905   {
14906     try {
14907       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14908     } catch (std::out_of_range& e) {
14909       {
14910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (std::exception& e) {
14913       {
14914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14915       };
14916     } catch (...) {
14917       {
14918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14919       };
14920     }
14921   }
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14928   void * jresult ;
14929   Dali::Vector3 *arg1 = 0 ;
14930   Dali::Property::Value *result = 0 ;
14931
14932   arg1 = (Dali::Vector3 *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (...) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14951       };
14952     }
14953   }
14954   jresult = (void *)result;
14955   return jresult;
14956 }
14957
14958
14959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14960   void * jresult ;
14961   Dali::Vector4 *arg1 = 0 ;
14962   Dali::Property::Value *result = 0 ;
14963
14964   arg1 = (Dali::Vector4 *)jarg1;
14965   if (!arg1) {
14966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14967     return 0;
14968   }
14969   {
14970     try {
14971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14972     } catch (std::out_of_range& e) {
14973       {
14974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14975       };
14976     } catch (std::exception& e) {
14977       {
14978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14983       };
14984     }
14985   }
14986   jresult = (void *)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14992   void * jresult ;
14993   Dali::Matrix3 *arg1 = 0 ;
14994   Dali::Property::Value *result = 0 ;
14995
14996   arg1 = (Dali::Matrix3 *)jarg1;
14997   if (!arg1) {
14998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14999     return 0;
15000   }
15001   {
15002     try {
15003       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15004     } catch (std::out_of_range& e) {
15005       {
15006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (std::exception& e) {
15009       {
15010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018   jresult = (void *)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15024   void * jresult ;
15025   Dali::Matrix *arg1 = 0 ;
15026   Dali::Property::Value *result = 0 ;
15027
15028   arg1 = (Dali::Matrix *)jarg1;
15029   if (!arg1) {
15030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15031     return 0;
15032   }
15033   {
15034     try {
15035       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15036     } catch (std::out_of_range& e) {
15037       {
15038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (std::exception& e) {
15041       {
15042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050   jresult = (void *)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15056   void * jresult ;
15057   Dali::Rect< int > *arg1 = 0 ;
15058   Dali::Property::Value *result = 0 ;
15059
15060   arg1 = (Dali::Rect< int > *)jarg1;
15061   if (!arg1) {
15062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15063     return 0;
15064   }
15065   {
15066     try {
15067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (...) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15079       };
15080     }
15081   }
15082   jresult = (void *)result;
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15088   void * jresult ;
15089   Dali::AngleAxis *arg1 = 0 ;
15090   Dali::Property::Value *result = 0 ;
15091
15092   arg1 = (Dali::AngleAxis *)jarg1;
15093   if (!arg1) {
15094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15095     return 0;
15096   }
15097   {
15098     try {
15099       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15100     } catch (std::out_of_range& e) {
15101       {
15102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15103       };
15104     } catch (std::exception& e) {
15105       {
15106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15111       };
15112     }
15113   }
15114   jresult = (void *)result;
15115   return jresult;
15116 }
15117
15118
15119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15120   void * jresult ;
15121   Dali::Quaternion *arg1 = 0 ;
15122   Dali::Property::Value *result = 0 ;
15123
15124   arg1 = (Dali::Quaternion *)jarg1;
15125   if (!arg1) {
15126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15127     return 0;
15128   }
15129   {
15130     try {
15131       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15132     } catch (std::out_of_range& e) {
15133       {
15134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15135       };
15136     } catch (std::exception& e) {
15137       {
15138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15143       };
15144     }
15145   }
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15152   void * jresult ;
15153   std::string *arg1 = 0 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   if (!jarg1) {
15157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15158     return 0;
15159   }
15160   std::string arg1_str(jarg1);
15161   arg1 = &arg1_str;
15162   {
15163     try {
15164       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15165     } catch (std::out_of_range& e) {
15166       {
15167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15168       };
15169     } catch (std::exception& e) {
15170       {
15171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15176       };
15177     }
15178   }
15179   jresult = (void *)result;
15180
15181   //argout typemap for const std::string&
15182
15183   return jresult;
15184 }
15185
15186
15187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15188   void * jresult ;
15189   Dali::Property::Array *arg1 = 0 ;
15190   Dali::Property::Value *result = 0 ;
15191
15192   arg1 = (Dali::Property::Array *)jarg1;
15193   if (!arg1) {
15194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15195     return 0;
15196   }
15197   {
15198     try {
15199       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15200     } catch (std::out_of_range& e) {
15201       {
15202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15203       };
15204     } catch (std::exception& e) {
15205       {
15206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15211       };
15212     }
15213   }
15214   jresult = (void *)result;
15215   return jresult;
15216 }
15217
15218
15219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15220   void * jresult ;
15221   Dali::Property::Map *arg1 = 0 ;
15222   Dali::Property::Value *result = 0 ;
15223
15224   arg1 = (Dali::Property::Map *)jarg1;
15225   if (!arg1) {
15226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15227     return 0;
15228   }
15229   {
15230     try {
15231       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15232     } catch (std::out_of_range& e) {
15233       {
15234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15235       };
15236     } catch (std::exception& e) {
15237       {
15238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15239       };
15240     } catch (...) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15243       };
15244     }
15245   }
15246   jresult = (void *)result;
15247   return jresult;
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15252   void * jresult ;
15253   Dali::Property::Type arg1 ;
15254   Dali::Property::Value *result = 0 ;
15255
15256   arg1 = (Dali::Property::Type)jarg1;
15257   {
15258     try {
15259       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15260     } catch (std::out_of_range& e) {
15261       {
15262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15263       };
15264     } catch (std::exception& e) {
15265       {
15266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (...) {
15269       {
15270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15271       };
15272     }
15273   }
15274   jresult = (void *)result;
15275   return jresult;
15276 }
15277
15278
15279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15280   void * jresult ;
15281   Dali::Property::Value *arg1 = 0 ;
15282   Dali::Property::Value *result = 0 ;
15283
15284   arg1 = (Dali::Property::Value *)jarg1;
15285   if (!arg1) {
15286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15287     return 0;
15288   }
15289   {
15290     try {
15291       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15292     } catch (std::out_of_range& e) {
15293       {
15294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (std::exception& e) {
15297       {
15298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15312   void * jresult ;
15313   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15314   Dali::Property::Value *arg2 = 0 ;
15315   Dali::Property::Value *result = 0 ;
15316
15317   arg1 = (Dali::Property::Value *)jarg1;
15318   arg2 = (Dali::Property::Value *)jarg2;
15319   if (!arg2) {
15320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15321     return 0;
15322   }
15323   {
15324     try {
15325       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (...) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15337       };
15338     }
15339   }
15340   jresult = (void *)result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15347
15348   arg1 = (Dali::Property::Value *)jarg1;
15349   {
15350     try {
15351       delete arg1;
15352     } catch (std::out_of_range& e) {
15353       {
15354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15355       };
15356     } catch (std::exception& e) {
15357       {
15358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15359       };
15360     } catch (...) {
15361       {
15362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15363       };
15364     }
15365   }
15366 }
15367
15368
15369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15370   int jresult ;
15371   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15372   Dali::Property::Type result;
15373
15374   arg1 = (Dali::Property::Value *)jarg1;
15375   {
15376     try {
15377       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15378     } catch (std::out_of_range& e) {
15379       {
15380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (std::exception& e) {
15383       {
15384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15385       };
15386     } catch (...) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15389       };
15390     }
15391   }
15392   jresult = (int)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15398   unsigned int jresult ;
15399   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15400   bool *arg2 = 0 ;
15401   bool result;
15402
15403   arg1 = (Dali::Property::Value *)jarg1;
15404   arg2 = (bool *)jarg2;
15405   {
15406     try {
15407       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15408     } catch (std::out_of_range& e) {
15409       {
15410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15411       };
15412     } catch (std::exception& e) {
15413       {
15414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15415       };
15416     } catch (...) {
15417       {
15418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15419       };
15420     }
15421   }
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15428   unsigned int jresult ;
15429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15430   float *arg2 = 0 ;
15431   bool result;
15432
15433   arg1 = (Dali::Property::Value *)jarg1;
15434   arg2 = (float *)jarg2;
15435   {
15436     try {
15437       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (...) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15449       };
15450     }
15451   }
15452   jresult = result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15458   unsigned int jresult ;
15459   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15460   int *arg2 = 0 ;
15461   bool result;
15462
15463   arg1 = (Dali::Property::Value *)jarg1;
15464   arg2 = (int *)jarg2;
15465   {
15466     try {
15467       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15468     } catch (std::out_of_range& e) {
15469       {
15470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15471       };
15472     } catch (std::exception& e) {
15473       {
15474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (...) {
15477       {
15478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15479       };
15480     }
15481   }
15482   jresult = result;
15483   return jresult;
15484 }
15485
15486
15487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15488   unsigned int jresult ;
15489   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15490   Dali::Rect< int > *arg2 = 0 ;
15491   bool result;
15492
15493   arg1 = (Dali::Property::Value *)jarg1;
15494   arg2 = (Dali::Rect< int > *)jarg2;
15495   if (!arg2) {
15496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15497     return 0;
15498   }
15499   {
15500     try {
15501       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15502     } catch (std::out_of_range& e) {
15503       {
15504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (std::exception& e) {
15507       {
15508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15509       };
15510     } catch (...) {
15511       {
15512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15513       };
15514     }
15515   }
15516   jresult = result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15522   unsigned int jresult ;
15523   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15524   Dali::Vector2 *arg2 = 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::Property::Value *)jarg1;
15528   arg2 = (Dali::Vector2 *)jarg2;
15529   if (!arg2) {
15530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15531     return 0;
15532   }
15533   {
15534     try {
15535       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15536     } catch (std::out_of_range& e) {
15537       {
15538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15539       };
15540     } catch (std::exception& e) {
15541       {
15542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (...) {
15545       {
15546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15547       };
15548     }
15549   }
15550   jresult = result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15556   unsigned int jresult ;
15557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15558   Dali::Vector3 *arg2 = 0 ;
15559   bool result;
15560
15561   arg1 = (Dali::Property::Value *)jarg1;
15562   arg2 = (Dali::Vector3 *)jarg2;
15563   if (!arg2) {
15564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15565     return 0;
15566   }
15567   {
15568     try {
15569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15570     } catch (std::out_of_range& e) {
15571       {
15572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (std::exception& e) {
15575       {
15576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15577       };
15578     } catch (...) {
15579       {
15580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15581       };
15582     }
15583   }
15584   jresult = result;
15585   return jresult;
15586 }
15587
15588
15589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15590   unsigned int jresult ;
15591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15592   Dali::Vector4 *arg2 = 0 ;
15593   bool result;
15594
15595   arg1 = (Dali::Property::Value *)jarg1;
15596   arg2 = (Dali::Vector4 *)jarg2;
15597   if (!arg2) {
15598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15599     return 0;
15600   }
15601   {
15602     try {
15603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15604     } catch (std::out_of_range& e) {
15605       {
15606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (std::exception& e) {
15609       {
15610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (...) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15615       };
15616     }
15617   }
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15626   Dali::Matrix3 *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Value *)jarg1;
15630   arg2 = (Dali::Matrix3 *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652   jresult = result;
15653   return jresult;
15654 }
15655
15656
15657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15658   unsigned int jresult ;
15659   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15660   Dali::Matrix *arg2 = 0 ;
15661   bool result;
15662
15663   arg1 = (Dali::Property::Value *)jarg1;
15664   arg2 = (Dali::Matrix *)jarg2;
15665   if (!arg2) {
15666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15667     return 0;
15668   }
15669   {
15670     try {
15671       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15683       };
15684     }
15685   }
15686   jresult = result;
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15694   Dali::AngleAxis *arg2 = 0 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Value *)jarg1;
15698   arg2 = (Dali::AngleAxis *)jarg2;
15699   if (!arg2) {
15700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15701     return 0;
15702   }
15703   {
15704     try {
15705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15706     } catch (std::out_of_range& e) {
15707       {
15708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (std::exception& e) {
15711       {
15712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (...) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15717       };
15718     }
15719   }
15720   jresult = result;
15721   return jresult;
15722 }
15723
15724
15725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15726   unsigned int jresult ;
15727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15728   Dali::Quaternion *arg2 = 0 ;
15729   bool result;
15730
15731   arg1 = (Dali::Property::Value *)jarg1;
15732   arg2 = (Dali::Quaternion *)jarg2;
15733   if (!arg2) {
15734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15735     return 0;
15736   }
15737   {
15738     try {
15739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15740     } catch (std::out_of_range& e) {
15741       {
15742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15743       };
15744     } catch (std::exception& e) {
15745       {
15746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (...) {
15749       {
15750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15751       };
15752     }
15753   }
15754   jresult = result;
15755   return jresult;
15756 }
15757
15758
15759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15760   unsigned int jresult ;
15761   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15762   std::string *arg2 = 0 ;
15763   bool result;
15764
15765   arg1 = (Dali::Property::Value *)jarg1;
15766
15767   //typemap in
15768   std::string temp;
15769   arg2 = &temp;
15770
15771   {
15772     try {
15773       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788   jresult = result;
15789
15790   //Typemap argout in c++ file.
15791   //This will convert c++ string to c# string
15792   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15793
15794   return jresult;
15795 }
15796
15797
15798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15799   unsigned int jresult ;
15800   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15801   Dali::Property::Array *arg2 = 0 ;
15802   bool result;
15803
15804   arg1 = (Dali::Property::Value *)jarg1;
15805   arg2 = (Dali::Property::Array *)jarg2;
15806   if (!arg2) {
15807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15808     return 0;
15809   }
15810   {
15811     try {
15812       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15813     } catch (std::out_of_range& e) {
15814       {
15815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (std::exception& e) {
15818       {
15819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827   jresult = result;
15828   return jresult;
15829 }
15830
15831
15832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15833   unsigned int jresult ;
15834   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15835   Dali::Property::Map *arg2 = 0 ;
15836   bool result;
15837
15838   arg1 = (Dali::Property::Value *)jarg1;
15839   arg2 = (Dali::Property::Map *)jarg2;
15840   if (!arg2) {
15841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15842     return 0;
15843   }
15844   {
15845     try {
15846       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15847     } catch (std::out_of_range& e) {
15848       {
15849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15850       };
15851     } catch (std::exception& e) {
15852       {
15853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (...) {
15856       {
15857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15858       };
15859     }
15860   }
15861   jresult = result;
15862   return jresult;
15863 }
15864
15865
15866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15867   void * jresult ;
15868   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15869   Dali::Property::Array *result = 0 ;
15870
15871   arg1 = (Dali::Property::Value *)jarg1;
15872   {
15873     try {
15874       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15875     } catch (std::out_of_range& e) {
15876       {
15877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15878       };
15879     } catch (std::exception& e) {
15880       {
15881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15882       };
15883     } catch (...) {
15884       {
15885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15886       };
15887     }
15888   }
15889   jresult = (void *)result;
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15895   void * jresult ;
15896   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15897   Dali::Property::Map *result = 0 ;
15898
15899   arg1 = (Dali::Property::Value *)jarg1;
15900   {
15901     try {
15902       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (...) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15914       };
15915     }
15916   }
15917   jresult = (void *)result;
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15923   char * jresult ;
15924   Dali::Property::Type arg1 ;
15925   char *result = 0 ;
15926
15927   arg1 = (Dali::Property::Type)jarg1;
15928   {
15929     try {
15930       result = (char *)Dali::PropertyTypes::GetName(arg1);
15931     } catch (std::out_of_range& e) {
15932       {
15933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15934       };
15935     } catch (std::exception& e) {
15936       {
15937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15938       };
15939     } catch (...) {
15940       {
15941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15942       };
15943     }
15944   }
15945   jresult = SWIG_csharp_string_callback((const char *)result);
15946   return jresult;
15947 }
15948
15949
15950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15951   unsigned int jresult ;
15952   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15953   std::string *arg2 = 0 ;
15954   Dali::Property::Map *arg3 = 0 ;
15955   bool result;
15956
15957   arg1 = (Dali::BaseObject *)jarg1;
15958   if (!jarg2) {
15959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15960     return 0;
15961   }
15962   std::string arg2_str(jarg2);
15963   arg2 = &arg2_str;
15964   arg3 = (Dali::Property::Map *)jarg3;
15965   if (!arg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15967     return 0;
15968   }
15969   {
15970     try {
15971       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15972     } catch (std::out_of_range& e) {
15973       {
15974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15975       };
15976     } catch (std::exception& e) {
15977       {
15978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (...) {
15981       {
15982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15983       };
15984     }
15985   }
15986   jresult = result;
15987
15988   //argout typemap for const std::string&
15989
15990   return jresult;
15991 }
15992
15993
15994 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15995   char * jresult ;
15996   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15997   std::string *result = 0 ;
15998
15999   arg1 = (Dali::BaseObject *)jarg1;
16000   {
16001     try {
16002       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16003     } catch (std::out_of_range& e) {
16004       {
16005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16006       };
16007     } catch (std::exception& e) {
16008       {
16009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16010       };
16011     } catch (...) {
16012       {
16013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16014       };
16015     }
16016   }
16017   jresult = SWIG_csharp_string_callback(result->c_str());
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16023   unsigned int jresult ;
16024   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16025   Dali::TypeInfo *arg2 = 0 ;
16026   bool result;
16027
16028   arg1 = (Dali::BaseObject *)jarg1;
16029   arg2 = (Dali::TypeInfo *)jarg2;
16030   if (!arg2) {
16031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16032     return 0;
16033   }
16034   {
16035     try {
16036       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16037     } catch (std::out_of_range& e) {
16038       {
16039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16040       };
16041     } catch (std::exception& e) {
16042       {
16043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16044       };
16045     } catch (...) {
16046       {
16047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16048       };
16049     }
16050   }
16051   jresult = result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16057   unsigned int jresult ;
16058   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16059   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16060   std::string *arg3 = 0 ;
16061   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16062   bool result;
16063
16064   arg1 = (Dali::BaseObject *)jarg1;
16065   arg2 = (ConnectionTrackerInterface *)jarg2;
16066   if (!jarg3) {
16067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16068     return 0;
16069   }
16070   std::string arg3_str(jarg3);
16071   arg3 = &arg3_str;
16072   arg4 = (FunctorDelegate *)jarg4;
16073   {
16074     try {
16075       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16076     } catch (std::out_of_range& e) {
16077       {
16078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16079       };
16080     } catch (std::exception& e) {
16081       {
16082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16087       };
16088     }
16089   }
16090   jresult = result;
16091
16092   //argout typemap for const std::string&
16093
16094   return jresult;
16095 }
16096
16097
16098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16099   void * jresult ;
16100   Dali::BaseHandle *arg1 = 0 ;
16101   Dali::BaseObject *result = 0 ;
16102
16103   arg1 = (Dali::BaseHandle *)jarg1;
16104   if (!arg1) {
16105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16106     return 0;
16107   }
16108   {
16109     try {
16110       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16111     } catch (std::out_of_range& e) {
16112       {
16113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (std::exception& e) {
16116       {
16117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16118       };
16119     } catch (...) {
16120       {
16121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16122       };
16123     }
16124   }
16125   jresult = (void *)result;
16126   return jresult;
16127 }
16128
16129
16130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16131   void * jresult ;
16132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16133   Dali::BaseHandle *result = 0 ;
16134
16135   arg1 = (Dali::BaseObject *)jarg1;
16136   {
16137     try {
16138       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16139     } catch (std::out_of_range& e) {
16140       {
16141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (std::exception& e) {
16144       {
16145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16159   void * jresult ;
16160   Dali::BaseHandle *result = 0 ;
16161
16162   {
16163     try {
16164       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16165     } catch (std::out_of_range& e) {
16166       {
16167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16168       };
16169     } catch (std::exception& e) {
16170       {
16171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16172       };
16173     } catch (...) {
16174       {
16175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16176       };
16177     }
16178   }
16179   jresult = (void *)result;
16180   return jresult;
16181 }
16182
16183
16184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16185   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16186
16187   arg1 = (Dali::BaseHandle *)jarg1;
16188   {
16189     try {
16190       delete arg1;
16191     } catch (std::out_of_range& e) {
16192       {
16193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16194       };
16195     } catch (std::exception& e) {
16196       {
16197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16198       };
16199     } catch (...) {
16200       {
16201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16202       };
16203     }
16204   }
16205 }
16206
16207
16208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16209   void * jresult ;
16210   Dali::BaseHandle *arg1 = 0 ;
16211   Dali::BaseHandle *result = 0 ;
16212
16213   arg1 = (Dali::BaseHandle *)jarg1;
16214   if (!arg1) {
16215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16216     return 0;
16217   }
16218   {
16219     try {
16220       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16221     } catch (std::out_of_range& e) {
16222       {
16223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (std::exception& e) {
16226       {
16227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (...) {
16230       {
16231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16232       };
16233     }
16234   }
16235   jresult = (void *)result;
16236   return jresult;
16237 }
16238
16239
16240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16241   void * jresult ;
16242   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16243   Dali::BaseHandle *arg2 = 0 ;
16244   Dali::BaseHandle *result = 0 ;
16245
16246   arg1 = (Dali::BaseHandle *)jarg1;
16247   arg2 = (Dali::BaseHandle *)jarg2;
16248   if (!arg2) {
16249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16250     return 0;
16251   }
16252   {
16253     try {
16254       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16255     } catch (std::out_of_range& e) {
16256       {
16257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16258       };
16259     } catch (std::exception& e) {
16260       {
16261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16262       };
16263     } catch (...) {
16264       {
16265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16266       };
16267     }
16268   }
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16275   unsigned int jresult ;
16276   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16277   std::string *arg2 = 0 ;
16278   Dali::Property::Map *arg3 = 0 ;
16279   bool result;
16280
16281   arg1 = (Dali::BaseHandle *)jarg1;
16282   if (!jarg2) {
16283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16284     return 0;
16285   }
16286   std::string arg2_str(jarg2);
16287   arg2 = &arg2_str;
16288   arg3 = (Dali::Property::Map *)jarg3;
16289   if (!arg3) {
16290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16291     return 0;
16292   }
16293   {
16294     try {
16295       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16296     } catch (std::out_of_range& e) {
16297       {
16298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16299       };
16300     } catch (std::exception& e) {
16301       {
16302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16303       };
16304     } catch (...) {
16305       {
16306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16307       };
16308     }
16309   }
16310   jresult = result;
16311
16312   //argout typemap for const std::string&
16313
16314   return jresult;
16315 }
16316
16317
16318 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16319   char * jresult ;
16320   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16321   std::string *result = 0 ;
16322
16323   arg1 = (Dali::BaseHandle *)jarg1;
16324   {
16325     try {
16326       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16327     } catch (std::out_of_range& e) {
16328       {
16329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16330       };
16331     } catch (std::exception& e) {
16332       {
16333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16334       };
16335     } catch (...) {
16336       {
16337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16338       };
16339     }
16340   }
16341   jresult = SWIG_csharp_string_callback(result->c_str());
16342   return jresult;
16343 }
16344
16345
16346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16347   unsigned int jresult ;
16348   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16349   Dali::TypeInfo *arg2 = 0 ;
16350   bool result;
16351
16352   arg1 = (Dali::BaseHandle *)jarg1;
16353   arg2 = (Dali::TypeInfo *)jarg2;
16354   if (!arg2) {
16355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16356     return 0;
16357   }
16358   {
16359     try {
16360       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16361     } catch (std::out_of_range& e) {
16362       {
16363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (std::exception& e) {
16366       {
16367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375   jresult = result;
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16381   void * jresult ;
16382   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16383   Dali::BaseObject *result = 0 ;
16384
16385   arg1 = (Dali::BaseHandle *)jarg1;
16386   {
16387     try {
16388       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16389     } catch (std::out_of_range& e) {
16390       {
16391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16392       };
16393     } catch (std::exception& e) {
16394       {
16395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (...) {
16398       {
16399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16400       };
16401     }
16402   }
16403   jresult = (void *)result;
16404   return jresult;
16405 }
16406
16407
16408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16409   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16410
16411   arg1 = (Dali::BaseHandle *)jarg1;
16412   {
16413     try {
16414       (arg1)->Reset();
16415     } catch (std::out_of_range& e) {
16416       {
16417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16418       };
16419     } catch (std::exception& e) {
16420       {
16421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16422       };
16423     } catch (...) {
16424       {
16425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16426       };
16427     }
16428   }
16429 }
16430
16431
16432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16433   unsigned int jresult ;
16434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16435   Dali::BaseHandle *arg2 = 0 ;
16436   bool result;
16437
16438   arg1 = (Dali::BaseHandle *)jarg1;
16439   arg2 = (Dali::BaseHandle *)jarg2;
16440   if (!arg2) {
16441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16442     return 0;
16443   }
16444   {
16445     try {
16446       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16447     } catch (std::out_of_range& e) {
16448       {
16449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (std::exception& e) {
16452       {
16453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (...) {
16456       {
16457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16458       };
16459     }
16460   }
16461   jresult = result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16467   unsigned int jresult ;
16468   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16469   Dali::BaseHandle *arg2 = 0 ;
16470   bool result;
16471
16472   arg1 = (Dali::BaseHandle *)jarg1;
16473   arg2 = (Dali::BaseHandle *)jarg2;
16474   if (!arg2) {
16475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16476     return 0;
16477   }
16478   {
16479     try {
16480       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16481     } catch (std::out_of_range& e) {
16482       {
16483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16484       };
16485     } catch (std::exception& e) {
16486       {
16487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (...) {
16490       {
16491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16492       };
16493     }
16494   }
16495   jresult = result;
16496   return jresult;
16497 }
16498
16499
16500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16501   void * jresult ;
16502   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16503   Dali::RefObject *result = 0 ;
16504
16505   arg1 = (Dali::BaseHandle *)jarg1;
16506   {
16507     try {
16508       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16509     } catch (std::out_of_range& e) {
16510       {
16511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16512       };
16513     } catch (std::exception& e) {
16514       {
16515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16520       };
16521     }
16522   }
16523   jresult = (void *)result;
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16529   unsigned int jresult ;
16530   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16531   bool result;
16532
16533   arg1 = (Dali::BaseHandle *)jarg1;
16534   {
16535     try {
16536       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16537     } catch (std::out_of_range& e) {
16538       {
16539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (std::exception& e) {
16542       {
16543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (...) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16548       };
16549     }
16550   }
16551   jresult = result;
16552   return jresult;
16553 }
16554
16555
16556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16557   unsigned int jresult ;
16558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16559   Dali::BaseHandle *arg2 = 0 ;
16560   bool result;
16561
16562   arg1 = (Dali::BaseHandle *)jarg1;
16563   arg2 = (Dali::BaseHandle *)jarg2;
16564   if (!arg2) {
16565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16566     return 0;
16567   }
16568   {
16569     try {
16570       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (...) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16582       };
16583     }
16584   }
16585   jresult = result;
16586   return jresult;
16587 }
16588
16589
16590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16591   unsigned int jresult ;
16592   Dali::BaseHandle *arg1 = 0 ;
16593   Dali::BaseHandle *arg2 = 0 ;
16594   bool result;
16595
16596   arg1 = (Dali::BaseHandle *)jarg1;
16597   if (!arg1) {
16598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16599     return 0;
16600   }
16601   arg2 = (Dali::BaseHandle *)jarg2;
16602   if (!arg2) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16604     return 0;
16605   }
16606   {
16607     try {
16608       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16609     } catch (std::out_of_range& e) {
16610       {
16611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16612       };
16613     } catch (std::exception& e) {
16614       {
16615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16616       };
16617     } catch (...) {
16618       {
16619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16620       };
16621     }
16622   }
16623   jresult = result;
16624   return jresult;
16625 }
16626
16627
16628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16629   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16630
16631   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16632   {
16633     try {
16634       delete arg1;
16635     } catch (std::out_of_range& e) {
16636       {
16637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16638       };
16639     } catch (std::exception& e) {
16640       {
16641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (...) {
16644       {
16645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16646       };
16647     }
16648   }
16649 }
16650
16651
16652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16653   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16654   SlotObserver *arg2 = (SlotObserver *) 0 ;
16655   CallbackBase *arg3 = (CallbackBase *) 0 ;
16656
16657   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16658   arg2 = (SlotObserver *)jarg2;
16659   arg3 = (CallbackBase *)jarg3;
16660   {
16661     try {
16662       (arg1)->SignalConnected(arg2,arg3);
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (...) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16674       };
16675     }
16676   }
16677 }
16678
16679
16680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16681   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16682
16683   arg1 = (Dali::SignalObserver *)jarg1;
16684   {
16685     try {
16686       delete arg1;
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16694       };
16695     } catch (...) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16698       };
16699     }
16700   }
16701 }
16702
16703
16704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16705   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16706   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16707   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16708
16709   arg1 = (Dali::SignalObserver *)jarg1;
16710   arg2 = (Dali::SlotObserver *)jarg2;
16711   arg3 = (Dali::CallbackBase *)jarg3;
16712   {
16713     try {
16714       (arg1)->SignalDisconnected(arg2,arg3);
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (...) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16726       };
16727     }
16728   }
16729 }
16730
16731
16732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16733   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16734
16735   arg1 = (Dali::SlotObserver *)jarg1;
16736   {
16737     try {
16738       delete arg1;
16739     } catch (std::out_of_range& e) {
16740       {
16741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16742       };
16743     } catch (std::exception& e) {
16744       {
16745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16746       };
16747     } catch (...) {
16748       {
16749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16750       };
16751     }
16752   }
16753 }
16754
16755
16756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16757   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16758   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16759
16760   arg1 = (Dali::SlotObserver *)jarg1;
16761   arg2 = (Dali::CallbackBase *)jarg2;
16762   {
16763     try {
16764       (arg1)->SlotDisconnected(arg2);
16765     } catch (std::out_of_range& e) {
16766       {
16767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16768       };
16769     } catch (std::exception& e) {
16770       {
16771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (...) {
16774       {
16775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16776       };
16777     }
16778   }
16779 }
16780
16781
16782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16783   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16784
16785   arg1 = (Dali::ConnectionTracker *)jarg1;
16786   {
16787     try {
16788       delete arg1;
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16800       };
16801     }
16802   }
16803 }
16804
16805
16806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16807   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16808
16809   arg1 = (Dali::ConnectionTracker *)jarg1;
16810   {
16811     try {
16812       (arg1)->DisconnectAll();
16813     } catch (std::out_of_range& e) {
16814       {
16815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16816       };
16817     } catch (std::exception& e) {
16818       {
16819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16820       };
16821     } catch (...) {
16822       {
16823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16824       };
16825     }
16826   }
16827 }
16828
16829
16830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16831   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16832   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16833   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16834
16835   arg1 = (Dali::ConnectionTracker *)jarg1;
16836   arg2 = (Dali::SlotObserver *)jarg2;
16837   arg3 = (Dali::CallbackBase *)jarg3;
16838   {
16839     try {
16840       (arg1)->SignalConnected(arg2,arg3);
16841     } catch (std::out_of_range& e) {
16842       {
16843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16844       };
16845     } catch (std::exception& e) {
16846       {
16847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16848       };
16849     } catch (...) {
16850       {
16851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16852       };
16853     }
16854   }
16855 }
16856
16857
16858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16859   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16860   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16861   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16862
16863   arg1 = (Dali::ConnectionTracker *)jarg1;
16864   arg2 = (Dali::SlotObserver *)jarg2;
16865   arg3 = (Dali::CallbackBase *)jarg3;
16866   {
16867     try {
16868       (arg1)->SignalDisconnected(arg2,arg3);
16869     } catch (std::out_of_range& e) {
16870       {
16871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16872       };
16873     } catch (std::exception& e) {
16874       {
16875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16876       };
16877     } catch (...) {
16878       {
16879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16880       };
16881     }
16882   }
16883 }
16884
16885
16886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16887   unsigned long jresult ;
16888   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16889   std::size_t result;
16890
16891   arg1 = (Dali::ConnectionTracker *)jarg1;
16892   {
16893     try {
16894       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (...) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16906       };
16907     }
16908   }
16909   jresult = (unsigned long)result;
16910   return jresult;
16911 }
16912
16913
16914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16915   void * jresult ;
16916   Dali::ObjectRegistry *result = 0 ;
16917
16918   {
16919     try {
16920       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16921     } catch (std::out_of_range& e) {
16922       {
16923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (std::exception& e) {
16926       {
16927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16928       };
16929     } catch (...) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16932       };
16933     }
16934   }
16935   jresult = (void *)result;
16936   return jresult;
16937 }
16938
16939
16940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16941   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16942
16943   arg1 = (Dali::ObjectRegistry *)jarg1;
16944   {
16945     try {
16946       delete arg1;
16947     } catch (std::out_of_range& e) {
16948       {
16949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16950       };
16951     } catch (std::exception& e) {
16952       {
16953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16954       };
16955     } catch (...) {
16956       {
16957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16958       };
16959     }
16960   }
16961 }
16962
16963
16964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16965   void * jresult ;
16966   Dali::ObjectRegistry *arg1 = 0 ;
16967   Dali::ObjectRegistry *result = 0 ;
16968
16969   arg1 = (Dali::ObjectRegistry *)jarg1;
16970   if (!arg1) {
16971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16972     return 0;
16973   }
16974   {
16975     try {
16976       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16977     } catch (std::out_of_range& e) {
16978       {
16979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (std::exception& e) {
16982       {
16983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16997   void * jresult ;
16998   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16999   Dali::ObjectRegistry *arg2 = 0 ;
17000   Dali::ObjectRegistry *result = 0 ;
17001
17002   arg1 = (Dali::ObjectRegistry *)jarg1;
17003   arg2 = (Dali::ObjectRegistry *)jarg2;
17004   if (!arg2) {
17005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17006     return 0;
17007   }
17008   {
17009     try {
17010       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17011     } catch (std::out_of_range& e) {
17012       {
17013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (std::exception& e) {
17016       {
17017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17031   void * jresult ;
17032   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17033   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17034
17035   arg1 = (Dali::ObjectRegistry *)jarg1;
17036   {
17037     try {
17038       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17039     } catch (std::out_of_range& e) {
17040       {
17041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17042       };
17043     } catch (std::exception& e) {
17044       {
17045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (...) {
17048       {
17049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17050       };
17051     }
17052   }
17053   jresult = (void *)result;
17054   return jresult;
17055 }
17056
17057
17058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17059   void * jresult ;
17060   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17061   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17062
17063   arg1 = (Dali::ObjectRegistry *)jarg1;
17064   {
17065     try {
17066       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081   jresult = (void *)result;
17082   return jresult;
17083 }
17084
17085
17086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17087   void * jresult ;
17088   Dali::PropertyCondition *result = 0 ;
17089
17090   {
17091     try {
17092       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17093     } catch (std::out_of_range& e) {
17094       {
17095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17096       };
17097     } catch (std::exception& e) {
17098       {
17099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17100       };
17101     } catch (...) {
17102       {
17103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17104       };
17105     }
17106   }
17107   jresult = (void *)result;
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17113   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17114
17115   arg1 = (Dali::PropertyCondition *)jarg1;
17116   {
17117     try {
17118       delete arg1;
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17126       };
17127     } catch (...) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17130       };
17131     }
17132   }
17133 }
17134
17135
17136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17137   void * jresult ;
17138   Dali::PropertyCondition *arg1 = 0 ;
17139   Dali::PropertyCondition *result = 0 ;
17140
17141   arg1 = (Dali::PropertyCondition *)jarg1;
17142   if (!arg1) {
17143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17144     return 0;
17145   }
17146   {
17147     try {
17148       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17149     } catch (std::out_of_range& e) {
17150       {
17151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (std::exception& e) {
17154       {
17155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17156       };
17157     } catch (...) {
17158       {
17159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17160       };
17161     }
17162   }
17163   jresult = (void *)result;
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17169   void * jresult ;
17170   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17171   Dali::PropertyCondition *arg2 = 0 ;
17172   Dali::PropertyCondition *result = 0 ;
17173
17174   arg1 = (Dali::PropertyCondition *)jarg1;
17175   arg2 = (Dali::PropertyCondition *)jarg2;
17176   if (!arg2) {
17177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17178     return 0;
17179   }
17180   {
17181     try {
17182       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17183     } catch (std::out_of_range& e) {
17184       {
17185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17186       };
17187     } catch (std::exception& e) {
17188       {
17189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (...) {
17192       {
17193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17194       };
17195     }
17196   }
17197   jresult = (void *)result;
17198   return jresult;
17199 }
17200
17201
17202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17203   unsigned long jresult ;
17204   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17205   std::size_t result;
17206
17207   arg1 = (Dali::PropertyCondition *)jarg1;
17208   {
17209     try {
17210       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17211     } catch (std::out_of_range& e) {
17212       {
17213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17214       };
17215     } catch (std::exception& e) {
17216       {
17217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (...) {
17220       {
17221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17222       };
17223     }
17224   }
17225   jresult = (unsigned long)result;
17226   return jresult;
17227 }
17228
17229
17230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17231   float jresult ;
17232   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17233   std::size_t arg2 ;
17234   float result;
17235
17236   arg1 = (Dali::PropertyCondition *)jarg1;
17237   arg2 = (std::size_t)jarg2;
17238   {
17239     try {
17240       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17241     } catch (std::out_of_range& e) {
17242       {
17243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17244       };
17245     } catch (std::exception& e) {
17246       {
17247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (...) {
17250       {
17251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17252       };
17253     }
17254   }
17255   jresult = result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17261   void * jresult ;
17262   float arg1 ;
17263   Dali::PropertyCondition result;
17264
17265   arg1 = (float)jarg1;
17266   {
17267     try {
17268       result = Dali::LessThanCondition(arg1);
17269     } catch (std::out_of_range& e) {
17270       {
17271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17272       };
17273     } catch (std::exception& e) {
17274       {
17275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (...) {
17278       {
17279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17280       };
17281     }
17282   }
17283   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17289   void * jresult ;
17290   float arg1 ;
17291   Dali::PropertyCondition result;
17292
17293   arg1 = (float)jarg1;
17294   {
17295     try {
17296       result = Dali::GreaterThanCondition(arg1);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (...) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17308       };
17309     }
17310   }
17311   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17312   return jresult;
17313 }
17314
17315
17316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17317   void * jresult ;
17318   float arg1 ;
17319   float arg2 ;
17320   Dali::PropertyCondition result;
17321
17322   arg1 = (float)jarg1;
17323   arg2 = (float)jarg2;
17324   {
17325     try {
17326       result = Dali::InsideCondition(arg1,arg2);
17327     } catch (std::out_of_range& e) {
17328       {
17329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (std::exception& e) {
17332       {
17333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17347   void * jresult ;
17348   float arg1 ;
17349   float arg2 ;
17350   Dali::PropertyCondition result;
17351
17352   arg1 = (float)jarg1;
17353   arg2 = (float)jarg2;
17354   {
17355     try {
17356       result = Dali::OutsideCondition(arg1,arg2);
17357     } catch (std::out_of_range& e) {
17358       {
17359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17360       };
17361     } catch (std::exception& e) {
17362       {
17363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (...) {
17366       {
17367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17368       };
17369     }
17370   }
17371   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17372   return jresult;
17373 }
17374
17375
17376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17377   void * jresult ;
17378   float arg1 ;
17379   float arg2 ;
17380   Dali::PropertyCondition result;
17381
17382   arg1 = (float)jarg1;
17383   arg2 = (float)jarg2;
17384   {
17385     try {
17386       result = Dali::StepCondition(arg1,arg2);
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (...) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17398       };
17399     }
17400   }
17401   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17402   return jresult;
17403 }
17404
17405
17406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17407   void * jresult ;
17408   float arg1 ;
17409   Dali::PropertyCondition result;
17410
17411   arg1 = (float)jarg1;
17412   {
17413     try {
17414       result = Dali::StepCondition(arg1);
17415     } catch (std::out_of_range& e) {
17416       {
17417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17418       };
17419     } catch (std::exception& e) {
17420       {
17421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17422       };
17423     } catch (...) {
17424       {
17425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17426       };
17427     }
17428   }
17429   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17430   return jresult;
17431 }
17432
17433
17434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17435   void * jresult ;
17436   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17437   Dali::PropertyCondition result;
17438
17439   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17440   if (!arg1) {
17441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17442     return 0;
17443   }
17444   {
17445     try {
17446       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17447     } catch (std::out_of_range& e) {
17448       {
17449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17450       };
17451     } catch (std::exception& e) {
17452       {
17453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17454       };
17455     } catch (...) {
17456       {
17457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17458       };
17459     }
17460   }
17461   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17462   return jresult;
17463 }
17464
17465
17466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17467   void * jresult ;
17468   Dali::PropertyNotification *result = 0 ;
17469
17470   {
17471     try {
17472       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17473     } catch (std::out_of_range& e) {
17474       {
17475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (std::exception& e) {
17478       {
17479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487   jresult = (void *)result;
17488   return jresult;
17489 }
17490
17491
17492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17493   void * jresult ;
17494   Dali::BaseHandle arg1 ;
17495   Dali::BaseHandle *argp1 ;
17496   Dali::PropertyNotification result;
17497
17498   argp1 = (Dali::BaseHandle *)jarg1;
17499   if (!argp1) {
17500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17501     return 0;
17502   }
17503   arg1 = *argp1;
17504   {
17505     try {
17506       result = Dali::PropertyNotification::DownCast(arg1);
17507     } catch (std::out_of_range& e) {
17508       {
17509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (std::exception& e) {
17512       {
17513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (...) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17518       };
17519     }
17520   }
17521   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17522   return jresult;
17523 }
17524
17525
17526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17527   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17528
17529   arg1 = (Dali::PropertyNotification *)jarg1;
17530   {
17531     try {
17532       delete arg1;
17533     } catch (std::out_of_range& e) {
17534       {
17535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17536       };
17537     } catch (std::exception& e) {
17538       {
17539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17544       };
17545     }
17546   }
17547 }
17548
17549
17550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17551   void * jresult ;
17552   Dali::PropertyNotification *arg1 = 0 ;
17553   Dali::PropertyNotification *result = 0 ;
17554
17555   arg1 = (Dali::PropertyNotification *)jarg1;
17556   if (!arg1) {
17557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17558     return 0;
17559   }
17560   {
17561     try {
17562       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17563     } catch (std::out_of_range& e) {
17564       {
17565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17566       };
17567     } catch (std::exception& e) {
17568       {
17569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (...) {
17572       {
17573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17574       };
17575     }
17576   }
17577   jresult = (void *)result;
17578   return jresult;
17579 }
17580
17581
17582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17583   void * jresult ;
17584   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17585   Dali::PropertyNotification *arg2 = 0 ;
17586   Dali::PropertyNotification *result = 0 ;
17587
17588   arg1 = (Dali::PropertyNotification *)jarg1;
17589   arg2 = (Dali::PropertyNotification *)jarg2;
17590   if (!arg2) {
17591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17592     return 0;
17593   }
17594   {
17595     try {
17596       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17597     } catch (std::out_of_range& e) {
17598       {
17599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17600       };
17601     } catch (std::exception& e) {
17602       {
17603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (...) {
17606       {
17607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17608       };
17609     }
17610   }
17611   jresult = (void *)result;
17612   return jresult;
17613 }
17614
17615
17616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17617   void * jresult ;
17618   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17619   Dali::PropertyCondition result;
17620
17621   arg1 = (Dali::PropertyNotification *)jarg1;
17622   {
17623     try {
17624       result = (arg1)->GetCondition();
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (...) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17636       };
17637     }
17638   }
17639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17645   void * jresult ;
17646   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17647   Dali::Handle result;
17648
17649   arg1 = (Dali::PropertyNotification *)jarg1;
17650   {
17651     try {
17652       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17653     } catch (std::out_of_range& e) {
17654       {
17655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17656       };
17657     } catch (std::exception& e) {
17658       {
17659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17660       };
17661     } catch (...) {
17662       {
17663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17664       };
17665     }
17666   }
17667   jresult = new Dali::Handle((const Dali::Handle &)result);
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17673   int jresult ;
17674   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17675   Dali::Property::Index result;
17676
17677   arg1 = (Dali::PropertyNotification *)jarg1;
17678   {
17679     try {
17680       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17681     } catch (std::out_of_range& e) {
17682       {
17683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (std::exception& e) {
17686       {
17687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (...) {
17690       {
17691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17692       };
17693     }
17694   }
17695   jresult = result;
17696   return jresult;
17697 }
17698
17699
17700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17701   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17702   Dali::PropertyNotification::NotifyMode arg2 ;
17703
17704   arg1 = (Dali::PropertyNotification *)jarg1;
17705   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17706   {
17707     try {
17708       (arg1)->SetNotifyMode(arg2);
17709     } catch (std::out_of_range& e) {
17710       {
17711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17712       };
17713     } catch (std::exception& e) {
17714       {
17715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17716       };
17717     } catch (...) {
17718       {
17719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17720       };
17721     }
17722   }
17723 }
17724
17725
17726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17727   int jresult ;
17728   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17729   Dali::PropertyNotification::NotifyMode result;
17730
17731   arg1 = (Dali::PropertyNotification *)jarg1;
17732   {
17733     try {
17734       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17735     } catch (std::out_of_range& e) {
17736       {
17737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17738       };
17739     } catch (std::exception& e) {
17740       {
17741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (...) {
17744       {
17745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17746       };
17747     }
17748   }
17749   jresult = (int)result;
17750   return jresult;
17751 }
17752
17753
17754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17755   unsigned int jresult ;
17756   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17757   bool result;
17758
17759   arg1 = (Dali::PropertyNotification *)jarg1;
17760   {
17761     try {
17762       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (...) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17774       };
17775     }
17776   }
17777   jresult = result;
17778   return jresult;
17779 }
17780
17781
17782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17783   void * jresult ;
17784   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17785   Dali::PropertyNotifySignalType *result = 0 ;
17786
17787   arg1 = (Dali::PropertyNotification *)jarg1;
17788   {
17789     try {
17790       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17791     } catch (std::out_of_range& e) {
17792       {
17793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17794       };
17795     } catch (std::exception& e) {
17796       {
17797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17798       };
17799     } catch (...) {
17800       {
17801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17802       };
17803     }
17804   }
17805   jresult = (void *)result;
17806   return jresult;
17807 }
17808
17809
17810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17811   void * jresult ;
17812   Dali::Handle *result = 0 ;
17813
17814   {
17815     try {
17816       result = (Dali::Handle *)new Dali::Handle();
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (...) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17828       };
17829     }
17830   }
17831   jresult = (void *)result;
17832   return jresult;
17833 }
17834
17835
17836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17837   void * jresult ;
17838   Dali::Handle result;
17839
17840   {
17841     try {
17842       result = Dali::Handle::New();
17843     } catch (std::out_of_range& e) {
17844       {
17845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (std::exception& e) {
17848       {
17849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17850       };
17851     } catch (...) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17854       };
17855     }
17856   }
17857   jresult = new Dali::Handle((const Dali::Handle &)result);
17858   return jresult;
17859 }
17860
17861
17862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17863   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17864
17865   arg1 = (Dali::Handle *)jarg1;
17866   {
17867     try {
17868       delete arg1;
17869     } catch (std::out_of_range& e) {
17870       {
17871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17872       };
17873     } catch (std::exception& e) {
17874       {
17875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17880       };
17881     }
17882   }
17883 }
17884
17885
17886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17887   void * jresult ;
17888   Dali::Handle *arg1 = 0 ;
17889   Dali::Handle *result = 0 ;
17890
17891   arg1 = (Dali::Handle *)jarg1;
17892   if (!arg1) {
17893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17894     return 0;
17895   }
17896   {
17897     try {
17898       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17899     } catch (std::out_of_range& e) {
17900       {
17901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (std::exception& e) {
17904       {
17905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (...) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17910       };
17911     }
17912   }
17913   jresult = (void *)result;
17914   return jresult;
17915 }
17916
17917
17918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17919   void * jresult ;
17920   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17921   Dali::Handle *arg2 = 0 ;
17922   Dali::Handle *result = 0 ;
17923
17924   arg1 = (Dali::Handle *)jarg1;
17925   arg2 = (Dali::Handle *)jarg2;
17926   if (!arg2) {
17927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17928     return 0;
17929   }
17930   {
17931     try {
17932       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17933     } catch (std::out_of_range& e) {
17934       {
17935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17936       };
17937     } catch (std::exception& e) {
17938       {
17939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (...) {
17942       {
17943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17944       };
17945     }
17946   }
17947   jresult = (void *)result;
17948   return jresult;
17949 }
17950
17951
17952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17953   void * jresult ;
17954   Dali::BaseHandle arg1 ;
17955   Dali::BaseHandle *argp1 ;
17956   Dali::Handle result;
17957
17958   argp1 = (Dali::BaseHandle *)jarg1;
17959   if (!argp1) {
17960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17961     return 0;
17962   }
17963   arg1 = *argp1;
17964   {
17965     try {
17966       result = Dali::Handle::DownCast(arg1);
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (...) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17978       };
17979     }
17980   }
17981   jresult = new Dali::Handle((const Dali::Handle &)result);
17982   return jresult;
17983 }
17984
17985
17986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17987   unsigned int jresult ;
17988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17989   Dali::Handle::Capability arg2 ;
17990   bool result;
17991
17992   arg1 = (Dali::Handle *)jarg1;
17993   arg2 = (Dali::Handle::Capability)jarg2;
17994   {
17995     try {
17996       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17997     } catch (std::out_of_range& e) {
17998       {
17999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18000       };
18001     } catch (std::exception& e) {
18002       {
18003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (...) {
18006       {
18007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18008       };
18009     }
18010   }
18011   jresult = result;
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18017   unsigned int jresult ;
18018   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18019   unsigned int result;
18020
18021   arg1 = (Dali::Handle *)jarg1;
18022   {
18023     try {
18024       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18025     } catch (std::out_of_range& e) {
18026       {
18027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18028       };
18029     } catch (std::exception& e) {
18030       {
18031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18032       };
18033     } catch (...) {
18034       {
18035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18036       };
18037     }
18038   }
18039   jresult = result;
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18045   char * jresult ;
18046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18047   Dali::Property::Index arg2 ;
18048   std::string result;
18049
18050   arg1 = (Dali::Handle *)jarg1;
18051   arg2 = (Dali::Property::Index)jarg2;
18052   {
18053     try {
18054       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18055     } catch (std::out_of_range& e) {
18056       {
18057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18058       };
18059     } catch (std::exception& e) {
18060       {
18061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (...) {
18064       {
18065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18066       };
18067     }
18068   }
18069   jresult = SWIG_csharp_string_callback((&result)->c_str());
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18075   int jresult ;
18076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18077   std::string *arg2 = 0 ;
18078   Dali::Property::Index result;
18079
18080   arg1 = (Dali::Handle *)jarg1;
18081   if (!jarg2) {
18082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18083     return 0;
18084   }
18085   std::string arg2_str(jarg2);
18086   arg2 = &arg2_str;
18087   {
18088     try {
18089       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18090     } catch (std::out_of_range& e) {
18091       {
18092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18093       };
18094     } catch (std::exception& e) {
18095       {
18096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (...) {
18099       {
18100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18101       };
18102     }
18103   }
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18113   unsigned int jresult ;
18114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18115   Dali::Property::Index arg2 ;
18116   bool result;
18117
18118   arg1 = (Dali::Handle *)jarg1;
18119   arg2 = (Dali::Property::Index)jarg2;
18120   {
18121     try {
18122       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18123     } catch (std::out_of_range& e) {
18124       {
18125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (std::exception& e) {
18128       {
18129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137   jresult = result;
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18143   unsigned int jresult ;
18144   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18145   Dali::Property::Index arg2 ;
18146   bool result;
18147
18148   arg1 = (Dali::Handle *)jarg1;
18149   arg2 = (Dali::Property::Index)jarg2;
18150   {
18151     try {
18152       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18153     } catch (std::out_of_range& e) {
18154       {
18155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18156       };
18157     } catch (std::exception& e) {
18158       {
18159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (...) {
18162       {
18163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18164       };
18165     }
18166   }
18167   jresult = result;
18168   return jresult;
18169 }
18170
18171
18172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18173   unsigned int jresult ;
18174   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18175   Dali::Property::Index arg2 ;
18176   bool result;
18177
18178   arg1 = (Dali::Handle *)jarg1;
18179   arg2 = (Dali::Property::Index)jarg2;
18180   {
18181     try {
18182       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18183     } catch (std::out_of_range& e) {
18184       {
18185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (std::exception& e) {
18188       {
18189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197   jresult = result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18203   int jresult ;
18204   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18205   Dali::Property::Index arg2 ;
18206   Dali::Property::Type result;
18207
18208   arg1 = (Dali::Handle *)jarg1;
18209   arg2 = (Dali::Property::Index)jarg2;
18210   {
18211     try {
18212       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18213     } catch (std::out_of_range& e) {
18214       {
18215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18216       };
18217     } catch (std::exception& e) {
18218       {
18219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18220       };
18221     } catch (...) {
18222       {
18223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18224       };
18225     }
18226   }
18227   jresult = (int)result;
18228   return jresult;
18229 }
18230
18231
18232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18233   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18234   Dali::Property::Index arg2 ;
18235   Dali::Property::Value *arg3 = 0 ;
18236
18237   arg1 = (Dali::Handle *)jarg1;
18238   arg2 = (Dali::Property::Index)jarg2;
18239   arg3 = (Dali::Property::Value *)jarg3;
18240   if (!arg3) {
18241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18242     return ;
18243   }
18244   {
18245     try {
18246       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18247     } catch (std::out_of_range& e) {
18248       {
18249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18250       };
18251     } catch (std::exception& e) {
18252       {
18253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18254       };
18255     } catch (...) {
18256       {
18257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18258       };
18259     }
18260   }
18261 }
18262
18263
18264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18265   int jresult ;
18266   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18267   std::string *arg2 = 0 ;
18268   Dali::Property::Value *arg3 = 0 ;
18269   Dali::Property::Index result;
18270
18271   arg1 = (Dali::Handle *)jarg1;
18272   if (!jarg2) {
18273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18274     return 0;
18275   }
18276   std::string arg2_str(jarg2);
18277   arg2 = &arg2_str;
18278   arg3 = (Dali::Property::Value *)jarg3;
18279   if (!arg3) {
18280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18281     return 0;
18282   }
18283   {
18284     try {
18285       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18286     } catch (std::out_of_range& e) {
18287       {
18288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18289       };
18290     } catch (std::exception& e) {
18291       {
18292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18293       };
18294     } catch (...) {
18295       {
18296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18297       };
18298     }
18299   }
18300   jresult = result;
18301
18302   //argout typemap for const std::string&
18303
18304   return jresult;
18305 }
18306
18307
18308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18309   int jresult ;
18310   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18311   std::string *arg2 = 0 ;
18312   Dali::Property::Value *arg3 = 0 ;
18313   Dali::Property::AccessMode arg4 ;
18314   Dali::Property::Index result;
18315
18316   arg1 = (Dali::Handle *)jarg1;
18317   if (!jarg2) {
18318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18319     return 0;
18320   }
18321   std::string arg2_str(jarg2);
18322   arg2 = &arg2_str;
18323   arg3 = (Dali::Property::Value *)jarg3;
18324   if (!arg3) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18326     return 0;
18327   }
18328   arg4 = (Dali::Property::AccessMode)jarg4;
18329   {
18330     try {
18331       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18332     } catch (std::out_of_range& e) {
18333       {
18334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (std::exception& e) {
18337       {
18338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346   jresult = result;
18347
18348   //argout typemap for const std::string&
18349
18350   return jresult;
18351 }
18352
18353
18354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18355   void * jresult ;
18356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18357   Dali::Property::Index arg2 ;
18358   Dali::Property::Value result;
18359
18360   arg1 = (Dali::Handle *)jarg1;
18361   arg2 = (Dali::Property::Index)jarg2;
18362   {
18363     try {
18364       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18365     } catch (std::out_of_range& e) {
18366       {
18367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18368       };
18369     } catch (std::exception& e) {
18370       {
18371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (...) {
18374       {
18375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18376       };
18377     }
18378   }
18379   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18380   return jresult;
18381 }
18382
18383
18384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18385   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18386   Dali::Property::IndexContainer *arg2 = 0 ;
18387
18388   arg1 = (Dali::Handle *)jarg1;
18389   arg2 = (Dali::Property::IndexContainer *)jarg2;
18390   if (!arg2) {
18391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18392     return ;
18393   }
18394   {
18395     try {
18396       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18397     } catch (std::out_of_range& e) {
18398       {
18399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18400       };
18401     } catch (std::exception& e) {
18402       {
18403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18408       };
18409     }
18410   }
18411 }
18412
18413
18414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18415   void * jresult ;
18416   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18417   Dali::Property::Index arg2 ;
18418   Dali::PropertyCondition *arg3 = 0 ;
18419   Dali::PropertyNotification result;
18420
18421   arg1 = (Dali::Handle *)jarg1;
18422   arg2 = (Dali::Property::Index)jarg2;
18423   arg3 = (Dali::PropertyCondition *)jarg3;
18424   if (!arg3) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (...) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18442       };
18443     }
18444   }
18445   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18446   return jresult;
18447 }
18448
18449
18450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18451   void * jresult ;
18452   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18453   Dali::Property::Index arg2 ;
18454   int arg3 ;
18455   Dali::PropertyCondition *arg4 = 0 ;
18456   Dali::PropertyNotification result;
18457
18458   arg1 = (Dali::Handle *)jarg1;
18459   arg2 = (Dali::Property::Index)jarg2;
18460   arg3 = (int)jarg3;
18461   arg4 = (Dali::PropertyCondition *)jarg4;
18462   if (!arg4) {
18463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18464     return 0;
18465   }
18466   {
18467     try {
18468       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18469     } catch (std::out_of_range& e) {
18470       {
18471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18472       };
18473     } catch (std::exception& e) {
18474       {
18475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18476       };
18477     } catch (...) {
18478       {
18479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18480       };
18481     }
18482   }
18483   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18484   return jresult;
18485 }
18486
18487
18488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18490   Dali::PropertyNotification arg2 ;
18491   Dali::PropertyNotification *argp2 ;
18492
18493   arg1 = (Dali::Handle *)jarg1;
18494   argp2 = (Dali::PropertyNotification *)jarg2;
18495   if (!argp2) {
18496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18497     return ;
18498   }
18499   arg2 = *argp2;
18500   {
18501     try {
18502       (arg1)->RemovePropertyNotification(arg2);
18503     } catch (std::out_of_range& e) {
18504       {
18505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18506       };
18507     } catch (std::exception& e) {
18508       {
18509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (...) {
18512       {
18513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18514       };
18515     }
18516   }
18517 }
18518
18519
18520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18521   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18522
18523   arg1 = (Dali::Handle *)jarg1;
18524   {
18525     try {
18526       (arg1)->RemovePropertyNotifications();
18527     } catch (std::out_of_range& e) {
18528       {
18529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18530       };
18531     } catch (std::exception& e) {
18532       {
18533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (...) {
18536       {
18537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18538       };
18539     }
18540   }
18541 }
18542
18543
18544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18545   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18546
18547   arg1 = (Dali::Handle *)jarg1;
18548   {
18549     try {
18550       (arg1)->RemoveConstraints();
18551     } catch (std::out_of_range& e) {
18552       {
18553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18554       };
18555     } catch (std::exception& e) {
18556       {
18557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18558       };
18559     } catch (...) {
18560       {
18561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18562       };
18563     }
18564   }
18565 }
18566
18567
18568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18569   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18570   unsigned int arg2 ;
18571
18572   arg1 = (Dali::Handle *)jarg1;
18573   arg2 = (unsigned int)jarg2;
18574   {
18575     try {
18576       (arg1)->RemoveConstraints(arg2);
18577     } catch (std::out_of_range& e) {
18578       {
18579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18580       };
18581     } catch (std::exception& e) {
18582       {
18583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18584       };
18585     } catch (...) {
18586       {
18587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18588       };
18589     }
18590   }
18591 }
18592
18593
18594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18595   int jresult ;
18596   Dali::Property::Index result;
18597
18598   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18599   jresult = result;
18600   return jresult;
18601 }
18602
18603
18604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18605   void * jresult ;
18606   Dali::Handle result;
18607
18608   {
18609     try {
18610       result = Dali::WeightObject::New();
18611     } catch (std::out_of_range& e) {
18612       {
18613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18614       };
18615     } catch (std::exception& e) {
18616       {
18617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18618       };
18619     } catch (...) {
18620       {
18621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18622       };
18623     }
18624   }
18625   jresult = new Dali::Handle((const Dali::Handle &)result);
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18631   void * jresult ;
18632   Dali::TypeInfo *result = 0 ;
18633
18634   {
18635     try {
18636       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18637     } catch (std::out_of_range& e) {
18638       {
18639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (std::exception& e) {
18642       {
18643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651   jresult = (void *)result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18657   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18658
18659   arg1 = (Dali::TypeInfo *)jarg1;
18660   {
18661     try {
18662       delete arg1;
18663     } catch (std::out_of_range& e) {
18664       {
18665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18666       };
18667     } catch (std::exception& e) {
18668       {
18669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18670       };
18671     } catch (...) {
18672       {
18673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18674       };
18675     }
18676   }
18677 }
18678
18679
18680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18681   void * jresult ;
18682   Dali::TypeInfo *arg1 = 0 ;
18683   Dali::TypeInfo *result = 0 ;
18684
18685   arg1 = (Dali::TypeInfo *)jarg1;
18686   if (!arg1) {
18687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18688     return 0;
18689   }
18690   {
18691     try {
18692       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18693     } catch (std::out_of_range& e) {
18694       {
18695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (std::exception& e) {
18698       {
18699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18700       };
18701     } catch (...) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18704       };
18705     }
18706   }
18707   jresult = (void *)result;
18708   return jresult;
18709 }
18710
18711
18712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18713   void * jresult ;
18714   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18715   Dali::TypeInfo *arg2 = 0 ;
18716   Dali::TypeInfo *result = 0 ;
18717
18718   arg1 = (Dali::TypeInfo *)jarg1;
18719   arg2 = (Dali::TypeInfo *)jarg2;
18720   if (!arg2) {
18721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18722     return 0;
18723   }
18724   {
18725     try {
18726       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (...) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18738       };
18739     }
18740   }
18741   jresult = (void *)result;
18742   return jresult;
18743 }
18744
18745
18746 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18747   char * jresult ;
18748   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18749   std::string *result = 0 ;
18750
18751   arg1 = (Dali::TypeInfo *)jarg1;
18752   {
18753     try {
18754       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18755     } catch (std::out_of_range& e) {
18756       {
18757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18758       };
18759     } catch (std::exception& e) {
18760       {
18761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (...) {
18764       {
18765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18766       };
18767     }
18768   }
18769   jresult = SWIG_csharp_string_callback(result->c_str());
18770   return jresult;
18771 }
18772
18773
18774 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18775   char * jresult ;
18776   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18777   std::string *result = 0 ;
18778
18779   arg1 = (Dali::TypeInfo *)jarg1;
18780   {
18781     try {
18782       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18783     } catch (std::out_of_range& e) {
18784       {
18785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (std::exception& e) {
18788       {
18789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797   jresult = SWIG_csharp_string_callback(result->c_str());
18798   return jresult;
18799 }
18800
18801
18802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18803   void * jresult ;
18804   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18805   Dali::BaseHandle result;
18806
18807   arg1 = (Dali::TypeInfo *)jarg1;
18808   {
18809     try {
18810       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18811     } catch (std::out_of_range& e) {
18812       {
18813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18814       };
18815     } catch (std::exception& e) {
18816       {
18817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18818       };
18819     } catch (...) {
18820       {
18821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18822       };
18823     }
18824   }
18825   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18826   return jresult;
18827 }
18828
18829
18830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18831   unsigned long jresult ;
18832   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18833   size_t result;
18834
18835   arg1 = (Dali::TypeInfo *)jarg1;
18836   {
18837     try {
18838       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18839     } catch (std::out_of_range& e) {
18840       {
18841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18842       };
18843     } catch (std::exception& e) {
18844       {
18845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18846       };
18847     } catch (...) {
18848       {
18849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18850       };
18851     }
18852   }
18853   jresult = (unsigned long)result;
18854   return jresult;
18855 }
18856
18857
18858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18859   char * jresult ;
18860   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18861   size_t arg2 ;
18862   std::string result;
18863
18864   arg1 = (Dali::TypeInfo *)jarg1;
18865   arg2 = (size_t)jarg2;
18866   {
18867     try {
18868       result = (arg1)->GetActionName(arg2);
18869     } catch (std::out_of_range& e) {
18870       {
18871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18872       };
18873     } catch (std::exception& e) {
18874       {
18875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (...) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18880       };
18881     }
18882   }
18883   jresult = SWIG_csharp_string_callback((&result)->c_str());
18884   return jresult;
18885 }
18886
18887
18888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18889   unsigned long jresult ;
18890   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18891   size_t result;
18892
18893   arg1 = (Dali::TypeInfo *)jarg1;
18894   {
18895     try {
18896       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18897     } catch (std::out_of_range& e) {
18898       {
18899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18900       };
18901     } catch (std::exception& e) {
18902       {
18903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18904       };
18905     } catch (...) {
18906       {
18907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18908       };
18909     }
18910   }
18911   jresult = (unsigned long)result;
18912   return jresult;
18913 }
18914
18915
18916 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18917   char * jresult ;
18918   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18919   size_t arg2 ;
18920   std::string result;
18921
18922   arg1 = (Dali::TypeInfo *)jarg1;
18923   arg2 = (size_t)jarg2;
18924   {
18925     try {
18926       result = (arg1)->GetSignalName(arg2);
18927     } catch (std::out_of_range& e) {
18928       {
18929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18930       };
18931     } catch (std::exception& e) {
18932       {
18933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18934       };
18935     } catch (...) {
18936       {
18937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18938       };
18939     }
18940   }
18941   jresult = SWIG_csharp_string_callback((&result)->c_str());
18942   return jresult;
18943 }
18944
18945
18946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18947   unsigned long jresult ;
18948   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18949   size_t result;
18950
18951   arg1 = (Dali::TypeInfo *)jarg1;
18952   {
18953     try {
18954       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18955     } catch (std::out_of_range& e) {
18956       {
18957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18958       };
18959     } catch (std::exception& e) {
18960       {
18961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18962       };
18963     } catch (...) {
18964       {
18965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18966       };
18967     }
18968   }
18969   jresult = (unsigned long)result;
18970   return jresult;
18971 }
18972
18973
18974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18975   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18976   Dali::Property::IndexContainer *arg2 = 0 ;
18977
18978   arg1 = (Dali::TypeInfo *)jarg1;
18979   arg2 = (Dali::Property::IndexContainer *)jarg2;
18980   if (!arg2) {
18981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18982     return ;
18983   }
18984   {
18985     try {
18986       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18987     } catch (std::out_of_range& e) {
18988       {
18989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18990       };
18991     } catch (std::exception& e) {
18992       {
18993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (...) {
18996       {
18997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18998       };
18999     }
19000   }
19001 }
19002
19003
19004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19005   char * jresult ;
19006   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19007   Dali::Property::Index arg2 ;
19008   std::string *result = 0 ;
19009
19010   arg1 = (Dali::TypeInfo *)jarg1;
19011   arg2 = (Dali::Property::Index)jarg2;
19012   {
19013     try {
19014       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19015     } catch (std::out_of_range& e) {
19016       {
19017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19018       };
19019     } catch (std::exception& e) {
19020       {
19021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19022       };
19023     } catch (...) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19026       };
19027     }
19028   }
19029   jresult = SWIG_csharp_string_callback(result->c_str());
19030   return jresult;
19031 }
19032
19033
19034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19035   void * jresult ;
19036   Dali::TypeRegistry result;
19037
19038   {
19039     try {
19040       result = Dali::TypeRegistry::Get();
19041     } catch (std::out_of_range& e) {
19042       {
19043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19044       };
19045     } catch (std::exception& e) {
19046       {
19047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19052       };
19053     }
19054   }
19055   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19056   return jresult;
19057 }
19058
19059
19060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19061   void * jresult ;
19062   Dali::TypeRegistry *result = 0 ;
19063
19064   {
19065     try {
19066       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19067     } catch (std::out_of_range& e) {
19068       {
19069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19070       };
19071     } catch (std::exception& e) {
19072       {
19073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19078       };
19079     }
19080   }
19081   jresult = (void *)result;
19082   return jresult;
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19087   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19088
19089   arg1 = (Dali::TypeRegistry *)jarg1;
19090   {
19091     try {
19092       delete arg1;
19093     } catch (std::out_of_range& e) {
19094       {
19095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19096       };
19097     } catch (std::exception& e) {
19098       {
19099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (...) {
19102       {
19103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19104       };
19105     }
19106   }
19107 }
19108
19109
19110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19111   void * jresult ;
19112   Dali::TypeRegistry *arg1 = 0 ;
19113   Dali::TypeRegistry *result = 0 ;
19114
19115   arg1 = (Dali::TypeRegistry *)jarg1;
19116   if (!arg1) {
19117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19118     return 0;
19119   }
19120   {
19121     try {
19122       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19123     } catch (std::out_of_range& e) {
19124       {
19125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19126       };
19127     } catch (std::exception& e) {
19128       {
19129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19130       };
19131     } catch (...) {
19132       {
19133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19134       };
19135     }
19136   }
19137   jresult = (void *)result;
19138   return jresult;
19139 }
19140
19141
19142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19143   void * jresult ;
19144   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19145   Dali::TypeRegistry *arg2 = 0 ;
19146   Dali::TypeRegistry *result = 0 ;
19147
19148   arg1 = (Dali::TypeRegistry *)jarg1;
19149   arg2 = (Dali::TypeRegistry *)jarg2;
19150   if (!arg2) {
19151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19152     return 0;
19153   }
19154   {
19155     try {
19156       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19168       };
19169     }
19170   }
19171   jresult = (void *)result;
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19177   void * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   std::string *arg2 = 0 ;
19180   Dali::TypeInfo result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   if (!jarg2) {
19184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19185     return 0;
19186   }
19187   std::string arg2_str(jarg2);
19188   arg2 = &arg2_str;
19189   {
19190     try {
19191       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (...) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19203       };
19204     }
19205   }
19206   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19207
19208   //argout typemap for const std::string&
19209
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19215   void * jresult ;
19216   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19217   std::type_info *arg2 = 0 ;
19218   Dali::TypeInfo result;
19219
19220   arg1 = (Dali::TypeRegistry *)jarg1;
19221   arg2 = (std::type_info *)jarg2;
19222   if (!arg2) {
19223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19224     return 0;
19225   }
19226   {
19227     try {
19228       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19229     } catch (std::out_of_range& e) {
19230       {
19231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (std::exception& e) {
19234       {
19235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19244   return jresult;
19245 }
19246
19247
19248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19249   unsigned long jresult ;
19250   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19251   size_t result;
19252
19253   arg1 = (Dali::TypeRegistry *)jarg1;
19254   {
19255     try {
19256       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (...) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19268       };
19269     }
19270   }
19271   jresult = (unsigned long)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19277   char * jresult ;
19278   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19279   size_t arg2 ;
19280   std::string result;
19281
19282   arg1 = (Dali::TypeRegistry *)jarg1;
19283   arg2 = (size_t)jarg2;
19284   {
19285     try {
19286       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19287     } catch (std::out_of_range& e) {
19288       {
19289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19290       };
19291     } catch (std::exception& e) {
19292       {
19293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (...) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19298       };
19299     }
19300   }
19301   jresult = SWIG_csharp_string_callback((&result)->c_str());
19302   return jresult;
19303 }
19304
19305
19306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19307   void * jresult ;
19308   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19309   Dali::TypeRegistry *result = 0 ;
19310
19311   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19312   {
19313     try {
19314       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329   jresult = (void *)result;
19330   return jresult;
19331 }
19332
19333
19334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19335   void * jresult ;
19336   std::type_info *arg1 = 0 ;
19337   std::type_info *arg2 = 0 ;
19338   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19339   Dali::TypeRegistration *result = 0 ;
19340
19341   arg1 = (std::type_info *)jarg1;
19342   if (!arg1) {
19343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19344     return 0;
19345   }
19346   arg2 = (std::type_info *)jarg2;
19347   if (!arg2) {
19348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19349     return 0;
19350   }
19351   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19352   {
19353     try {
19354       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19355     } catch (std::out_of_range& e) {
19356       {
19357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19358       };
19359     } catch (std::exception& e) {
19360       {
19361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (...) {
19364       {
19365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19366       };
19367     }
19368   }
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19375   void * jresult ;
19376   std::type_info *arg1 = 0 ;
19377   std::type_info *arg2 = 0 ;
19378   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19379   bool arg4 ;
19380   Dali::TypeRegistration *result = 0 ;
19381
19382   arg1 = (std::type_info *)jarg1;
19383   if (!arg1) {
19384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19385     return 0;
19386   }
19387   arg2 = (std::type_info *)jarg2;
19388   if (!arg2) {
19389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19390     return 0;
19391   }
19392   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19393   arg4 = jarg4 ? true : false;
19394   {
19395     try {
19396       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19397     } catch (std::out_of_range& e) {
19398       {
19399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (std::exception& e) {
19402       {
19403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411   jresult = (void *)result;
19412   return jresult;
19413 }
19414
19415
19416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19417   void * jresult ;
19418   std::string *arg1 = 0 ;
19419   std::type_info *arg2 = 0 ;
19420   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19421   Dali::TypeRegistration *result = 0 ;
19422
19423   if (!jarg1) {
19424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19425     return 0;
19426   }
19427   std::string arg1_str(jarg1);
19428   arg1 = &arg1_str;
19429   arg2 = (std::type_info *)jarg2;
19430   if (!arg2) {
19431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19432     return 0;
19433   }
19434   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19435   {
19436     try {
19437       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19438     } catch (std::out_of_range& e) {
19439       {
19440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19441       };
19442     } catch (std::exception& e) {
19443       {
19444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19445       };
19446     } catch (...) {
19447       {
19448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19449       };
19450     }
19451   }
19452   jresult = (void *)result;
19453
19454   //argout typemap for const std::string&
19455
19456   return jresult;
19457 }
19458
19459
19460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19461   char * jresult ;
19462   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19463   std::string result;
19464
19465   arg1 = (Dali::TypeRegistration *)jarg1;
19466   {
19467     try {
19468       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19469     } catch (std::out_of_range& e) {
19470       {
19471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19472       };
19473     } catch (std::exception& e) {
19474       {
19475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19476       };
19477     } catch (...) {
19478       {
19479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19480       };
19481     }
19482   }
19483   jresult = SWIG_csharp_string_callback((&result)->c_str());
19484   return jresult;
19485 }
19486
19487
19488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19489   std::string *arg1 = 0 ;
19490   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19491
19492   if (!jarg1) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19494     return ;
19495   }
19496   std::string arg1_str(jarg1);
19497   arg1 = &arg1_str;
19498   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19499   {
19500     try {
19501       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19502     } catch (std::out_of_range& e) {
19503       {
19504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19505       };
19506     } catch (std::exception& e) {
19507       {
19508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19513       };
19514     }
19515   }
19516
19517   //argout typemap for const std::string&
19518
19519 }
19520
19521
19522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19523   std::string *arg1 = 0 ;
19524   std::string *arg2 = 0 ;
19525   int arg3 ;
19526   Dali::Property::Type arg4 ;
19527   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19528   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19529
19530   if (!jarg1) {
19531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19532     return ;
19533   }
19534   std::string arg1_str(jarg1);
19535   arg1 = &arg1_str;
19536   if (!jarg2) {
19537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19538     return ;
19539   }
19540   std::string arg2_str(jarg2);
19541   arg2 = &arg2_str;
19542   arg3 = (int)jarg3;
19543   arg4 = (Dali::Property::Type)jarg4;
19544   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19545   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19546   {
19547     try {
19548       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19549     } catch (std::out_of_range& e) {
19550       {
19551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19552       };
19553     } catch (std::exception& e) {
19554       {
19555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19556       };
19557     } catch (...) {
19558       {
19559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19560       };
19561     }
19562   }
19563
19564   //argout typemap for const std::string&
19565
19566
19567   //argout typemap for const std::string&
19568
19569 }
19570
19571
19572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19573   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19574
19575   arg1 = (Dali::TypeRegistration *)jarg1;
19576   {
19577     try {
19578       delete arg1;
19579     } catch (std::out_of_range& e) {
19580       {
19581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19582       };
19583     } catch (std::exception& e) {
19584       {
19585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19586       };
19587     } catch (...) {
19588       {
19589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19590       };
19591     }
19592   }
19593 }
19594
19595
19596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19597   void * jresult ;
19598   Dali::TypeRegistration *arg1 = 0 ;
19599   std::string *arg2 = 0 ;
19600   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19601   Dali::SignalConnectorType *result = 0 ;
19602
19603   arg1 = (Dali::TypeRegistration *)jarg1;
19604   if (!arg1) {
19605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19606     return 0;
19607   }
19608   if (!jarg2) {
19609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19610     return 0;
19611   }
19612   std::string arg2_str(jarg2);
19613   arg2 = &arg2_str;
19614   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19615   {
19616     try {
19617       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19618     } catch (std::out_of_range& e) {
19619       {
19620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19621       };
19622     } catch (std::exception& e) {
19623       {
19624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (...) {
19627       {
19628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19629       };
19630     }
19631   }
19632   jresult = (void *)result;
19633
19634   //argout typemap for const std::string&
19635
19636   return jresult;
19637 }
19638
19639
19640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19641   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19642
19643   arg1 = (Dali::SignalConnectorType *)jarg1;
19644   {
19645     try {
19646       delete arg1;
19647     } catch (std::out_of_range& e) {
19648       {
19649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19650       };
19651     } catch (std::exception& e) {
19652       {
19653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19658       };
19659     }
19660   }
19661 }
19662
19663
19664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19665   void * jresult ;
19666   Dali::TypeRegistration *arg1 = 0 ;
19667   std::string *arg2 = 0 ;
19668   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19669   Dali::TypeAction *result = 0 ;
19670
19671   arg1 = (Dali::TypeRegistration *)jarg1;
19672   if (!arg1) {
19673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19674     return 0;
19675   }
19676   if (!jarg2) {
19677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19678     return 0;
19679   }
19680   std::string arg2_str(jarg2);
19681   arg2 = &arg2_str;
19682   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19683   {
19684     try {
19685       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19686     } catch (std::out_of_range& e) {
19687       {
19688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19689       };
19690     } catch (std::exception& e) {
19691       {
19692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19693       };
19694     } catch (...) {
19695       {
19696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19697       };
19698     }
19699   }
19700   jresult = (void *)result;
19701
19702   //argout typemap for const std::string&
19703
19704   return jresult;
19705 }
19706
19707
19708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19709   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19710
19711   arg1 = (Dali::TypeAction *)jarg1;
19712   {
19713     try {
19714       delete arg1;
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19726       };
19727     }
19728   }
19729 }
19730
19731
19732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19733   void * jresult ;
19734   Dali::TypeRegistration *arg1 = 0 ;
19735   std::string *arg2 = 0 ;
19736   Dali::Property::Index arg3 ;
19737   Dali::Property::Type arg4 ;
19738   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19739   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19740   Dali::PropertyRegistration *result = 0 ;
19741
19742   arg1 = (Dali::TypeRegistration *)jarg1;
19743   if (!arg1) {
19744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19745     return 0;
19746   }
19747   if (!jarg2) {
19748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19749     return 0;
19750   }
19751   std::string arg2_str(jarg2);
19752   arg2 = &arg2_str;
19753   arg3 = (Dali::Property::Index)jarg3;
19754   arg4 = (Dali::Property::Type)jarg4;
19755   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19756   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19757   {
19758     try {
19759       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (...) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19771       };
19772     }
19773   }
19774   jresult = (void *)result;
19775
19776   //argout typemap for const std::string&
19777
19778   return jresult;
19779 }
19780
19781
19782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19783   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19784
19785   arg1 = (Dali::PropertyRegistration *)jarg1;
19786   {
19787     try {
19788       delete arg1;
19789     } catch (std::out_of_range& e) {
19790       {
19791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19792       };
19793     } catch (std::exception& e) {
19794       {
19795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19796       };
19797     } catch (...) {
19798       {
19799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19800       };
19801     }
19802   }
19803 }
19804
19805
19806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19807   void * jresult ;
19808   Dali::TypeRegistration *arg1 = 0 ;
19809   std::string *arg2 = 0 ;
19810   Dali::Property::Index arg3 ;
19811   Dali::Property::Type arg4 ;
19812   Dali::AnimatablePropertyRegistration *result = 0 ;
19813
19814   arg1 = (Dali::TypeRegistration *)jarg1;
19815   if (!arg1) {
19816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19817     return 0;
19818   }
19819   if (!jarg2) {
19820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19821     return 0;
19822   }
19823   std::string arg2_str(jarg2);
19824   arg2 = &arg2_str;
19825   arg3 = (Dali::Property::Index)jarg3;
19826   arg4 = (Dali::Property::Type)jarg4;
19827   {
19828     try {
19829       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19830     } catch (std::out_of_range& e) {
19831       {
19832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (std::exception& e) {
19835       {
19836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (...) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19841       };
19842     }
19843   }
19844   jresult = (void *)result;
19845
19846   //argout typemap for const std::string&
19847
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19853   void * jresult ;
19854   Dali::TypeRegistration *arg1 = 0 ;
19855   std::string *arg2 = 0 ;
19856   Dali::Property::Index arg3 ;
19857   Dali::Property::Value *arg4 = 0 ;
19858   Dali::AnimatablePropertyRegistration *result = 0 ;
19859
19860   arg1 = (Dali::TypeRegistration *)jarg1;
19861   if (!arg1) {
19862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19863     return 0;
19864   }
19865   if (!jarg2) {
19866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19867     return 0;
19868   }
19869   std::string arg2_str(jarg2);
19870   arg2 = &arg2_str;
19871   arg3 = (Dali::Property::Index)jarg3;
19872   arg4 = (Dali::Property::Value *)jarg4;
19873   if (!arg4) {
19874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19875     return 0;
19876   }
19877   {
19878     try {
19879       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19887       };
19888     } catch (...) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19891       };
19892     }
19893   }
19894   jresult = (void *)result;
19895
19896   //argout typemap for const std::string&
19897
19898   return jresult;
19899 }
19900
19901
19902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19903   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19904
19905   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19906   {
19907     try {
19908       delete arg1;
19909     } catch (std::out_of_range& e) {
19910       {
19911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19912       };
19913     } catch (std::exception& e) {
19914       {
19915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19916       };
19917     } catch (...) {
19918       {
19919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19920       };
19921     }
19922   }
19923 }
19924
19925
19926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19927   void * jresult ;
19928   Dali::TypeRegistration *arg1 = 0 ;
19929   std::string *arg2 = 0 ;
19930   Dali::Property::Index arg3 ;
19931   Dali::Property::Index arg4 ;
19932   unsigned int arg5 ;
19933   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19934
19935   arg1 = (Dali::TypeRegistration *)jarg1;
19936   if (!arg1) {
19937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19938     return 0;
19939   }
19940   if (!jarg2) {
19941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19942     return 0;
19943   }
19944   std::string arg2_str(jarg2);
19945   arg2 = &arg2_str;
19946   arg3 = (Dali::Property::Index)jarg3;
19947   arg4 = (Dali::Property::Index)jarg4;
19948   arg5 = (unsigned int)jarg5;
19949   {
19950     try {
19951       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (...) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19963       };
19964     }
19965   }
19966   jresult = (void *)result;
19967
19968   //argout typemap for const std::string&
19969
19970   return jresult;
19971 }
19972
19973
19974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19975   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19976
19977   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19978   {
19979     try {
19980       delete arg1;
19981     } catch (std::out_of_range& e) {
19982       {
19983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19984       };
19985     } catch (std::exception& e) {
19986       {
19987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19988       };
19989     } catch (...) {
19990       {
19991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19992       };
19993     }
19994   }
19995 }
19996
19997
19998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19999   void * jresult ;
20000   Dali::TypeRegistration *arg1 = 0 ;
20001   std::string *arg2 = 0 ;
20002   Dali::Property::Index arg3 ;
20003   Dali::Property::Type arg4 ;
20004   Dali::ChildPropertyRegistration *result = 0 ;
20005
20006   arg1 = (Dali::TypeRegistration *)jarg1;
20007   if (!arg1) {
20008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20009     return 0;
20010   }
20011   if (!jarg2) {
20012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20013     return 0;
20014   }
20015   std::string arg2_str(jarg2);
20016   arg2 = &arg2_str;
20017   arg3 = (Dali::Property::Index)jarg3;
20018   arg4 = (Dali::Property::Type)jarg4;
20019   {
20020     try {
20021       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20022     } catch (std::out_of_range& e) {
20023       {
20024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20025       };
20026     } catch (std::exception& e) {
20027       {
20028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (...) {
20031       {
20032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20033       };
20034     }
20035   }
20036   jresult = (void *)result;
20037
20038   //argout typemap for const std::string&
20039
20040   return jresult;
20041 }
20042
20043
20044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20045   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20046
20047   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20048   {
20049     try {
20050       delete arg1;
20051     } catch (std::out_of_range& e) {
20052       {
20053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20054       };
20055     } catch (std::exception& e) {
20056       {
20057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20058       };
20059     } catch (...) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20062       };
20063     }
20064   }
20065 }
20066
20067
20068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20069   unsigned int jresult ;
20070   std::string *arg1 = 0 ;
20071   std::type_info *arg2 = 0 ;
20072   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20073   bool result;
20074
20075   if (!jarg1) {
20076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20077     return 0;
20078   }
20079   std::string arg1_str(jarg1);
20080   arg1 = &arg1_str;
20081   arg2 = (std::type_info *)jarg2;
20082   if (!arg2) {
20083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20084     return 0;
20085   }
20086   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20087   {
20088     try {
20089       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20090     } catch (std::out_of_range& e) {
20091       {
20092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20093       };
20094     } catch (std::exception& e) {
20095       {
20096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (...) {
20099       {
20100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20101       };
20102     }
20103   }
20104   jresult = result;
20105
20106   //argout typemap for const std::string&
20107
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20113   unsigned int jresult ;
20114   std::string *arg1 = 0 ;
20115   std::string *arg2 = 0 ;
20116   Dali::Property::Index arg3 ;
20117   Dali::Property::Type arg4 ;
20118   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20119   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20120   bool result;
20121
20122   if (!jarg1) {
20123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20124     return 0;
20125   }
20126   std::string arg1_str(jarg1);
20127   arg1 = &arg1_str;
20128   if (!jarg2) {
20129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20130     return 0;
20131   }
20132   std::string arg2_str(jarg2);
20133   arg2 = &arg2_str;
20134   arg3 = (Dali::Property::Index)jarg3;
20135   arg4 = (Dali::Property::Type)jarg4;
20136   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20137   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20138   {
20139     try {
20140       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20148       };
20149     } catch (...) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20152       };
20153     }
20154   }
20155   jresult = result;
20156
20157   //argout typemap for const std::string&
20158
20159
20160   //argout typemap for const std::string&
20161
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20167   float jresult ;
20168   float result;
20169
20170   result = (float)(float)Dali::ParentOrigin::TOP;
20171   jresult = result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20177   float jresult ;
20178   float result;
20179
20180   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20187   float jresult ;
20188   float result;
20189
20190   result = (float)(float)Dali::ParentOrigin::LEFT;
20191   jresult = result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20197   float jresult ;
20198   float result;
20199
20200   result = (float)(float)Dali::ParentOrigin::RIGHT;
20201   jresult = result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20207   float jresult ;
20208   float result;
20209
20210   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20217   void * jresult ;
20218   Dali::Vector3 *result = 0 ;
20219
20220   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20227   void * jresult ;
20228   Dali::Vector3 *result = 0 ;
20229
20230   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20237   void * jresult ;
20238   Dali::Vector3 *result = 0 ;
20239
20240   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20247   void * jresult ;
20248   Dali::Vector3 *result = 0 ;
20249
20250   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20287   void * jresult ;
20288   Dali::Vector3 *result = 0 ;
20289
20290   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20291   jresult = (void *)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20297   void * jresult ;
20298   Dali::Vector3 *result = 0 ;
20299
20300   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20301   jresult = (void *)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20307   float jresult ;
20308   float result;
20309
20310   result = (float)(float)Dali::AnchorPoint::TOP;
20311   jresult = result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20317   float jresult ;
20318   float result;
20319
20320   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20327   float jresult ;
20328   float result;
20329
20330   result = (float)(float)Dali::AnchorPoint::LEFT;
20331   jresult = result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20337   float jresult ;
20338   float result;
20339
20340   result = (float)(float)Dali::AnchorPoint::RIGHT;
20341   jresult = result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20347   float jresult ;
20348   float result;
20349
20350   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20351   jresult = result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20357   void * jresult ;
20358   Dali::Vector3 *result = 0 ;
20359
20360   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20367   void * jresult ;
20368   Dali::Vector3 *result = 0 ;
20369
20370   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20377   void * jresult ;
20378   Dali::Vector3 *result = 0 ;
20379
20380   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20387   void * jresult ;
20388   Dali::Vector3 *result = 0 ;
20389
20390   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20397   void * jresult ;
20398   Dali::Vector3 *result = 0 ;
20399
20400   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20407   void * jresult ;
20408   Dali::Vector3 *result = 0 ;
20409
20410   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20417   void * jresult ;
20418   Dali::Vector3 *result = 0 ;
20419
20420   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20427   void * jresult ;
20428   Dali::Vector3 *result = 0 ;
20429
20430   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20437   void * jresult ;
20438   Dali::Vector3 *result = 0 ;
20439
20440   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20447   void * jresult ;
20448   Dali::Vector4 *result = 0 ;
20449
20450   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20457   void * jresult ;
20458   Dali::Vector4 *result = 0 ;
20459
20460   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20461   jresult = (void *)result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20467   void * jresult ;
20468   Dali::Vector4 *result = 0 ;
20469
20470   result = (Dali::Vector4 *)&Dali::Color::RED;
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20477   void * jresult ;
20478   Dali::Vector4 *result = 0 ;
20479
20480   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20481   jresult = (void *)result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20487   void * jresult ;
20488   Dali::Vector4 *result = 0 ;
20489
20490   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20491   jresult = (void *)result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20497   void * jresult ;
20498   Dali::Vector4 *result = 0 ;
20499
20500   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20501   jresult = (void *)result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20507   void * jresult ;
20508   Dali::Vector4 *result = 0 ;
20509
20510   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20511   jresult = (void *)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20517   void * jresult ;
20518   Dali::Vector4 *result = 0 ;
20519
20520   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20521   jresult = (void *)result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20527   void * jresult ;
20528   Dali::Vector4 *result = 0 ;
20529
20530   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20531   jresult = (void *)result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20547   float jresult ;
20548   float result;
20549
20550   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20557   float jresult ;
20558   float result;
20559
20560   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20561   jresult = result;
20562   return jresult;
20563 }
20564
20565
20566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20567   float jresult ;
20568   float result;
20569
20570   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20577   float jresult ;
20578   float result;
20579
20580   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20581   jresult = result;
20582   return jresult;
20583 }
20584
20585
20586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20587   float jresult ;
20588   float result;
20589
20590   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20591   jresult = result;
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20597   float jresult ;
20598   float result;
20599
20600   result = (float)(float)Dali::Math::PI;
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20607   float jresult ;
20608   float result;
20609
20610   result = (float)(float)Dali::Math::PI_2;
20611   jresult = result;
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20617   float jresult ;
20618   float result;
20619
20620   result = (float)(float)Dali::Math::PI_4;
20621   jresult = result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20627   float jresult ;
20628   float result;
20629
20630   result = (float)(float)Dali::Math::PI_OVER_180;
20631   jresult = result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20637   float jresult ;
20638   float result;
20639
20640   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20641   jresult = result;
20642   return jresult;
20643 }
20644
20645
20646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20647   int jresult ;
20648   Dali::ResizePolicy::Type result;
20649
20650   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20651   jresult = (int)result;
20652   return jresult;
20653 }
20654
20655
20656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20657   unsigned long jresult ;
20658   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20659   Dali::VectorBase::SizeType result;
20660
20661   arg1 = (Dali::VectorBase *)jarg1;
20662   {
20663     try {
20664       result = ((Dali::VectorBase const *)arg1)->Count();
20665     } catch (std::out_of_range& e) {
20666       {
20667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (std::exception& e) {
20670       {
20671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679   jresult = (unsigned long)result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20685   unsigned long jresult ;
20686   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20687   Dali::VectorBase::SizeType result;
20688
20689   arg1 = (Dali::VectorBase *)jarg1;
20690   {
20691     try {
20692       result = ((Dali::VectorBase const *)arg1)->Size();
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (...) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20704       };
20705     }
20706   }
20707   jresult = (unsigned long)result;
20708   return jresult;
20709 }
20710
20711
20712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20713   unsigned int jresult ;
20714   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20715   bool result;
20716
20717   arg1 = (Dali::VectorBase *)jarg1;
20718   {
20719     try {
20720       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20721     } catch (std::out_of_range& e) {
20722       {
20723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20724       };
20725     } catch (std::exception& e) {
20726       {
20727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20728       };
20729     } catch (...) {
20730       {
20731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20732       };
20733     }
20734   }
20735   jresult = result;
20736   return jresult;
20737 }
20738
20739
20740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20741   unsigned long jresult ;
20742   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20743   Dali::VectorBase::SizeType result;
20744
20745   arg1 = (Dali::VectorBase *)jarg1;
20746   {
20747     try {
20748       result = ((Dali::VectorBase const *)arg1)->Capacity();
20749     } catch (std::out_of_range& e) {
20750       {
20751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20752       };
20753     } catch (std::exception& e) {
20754       {
20755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20756       };
20757     } catch (...) {
20758       {
20759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20760       };
20761     }
20762   }
20763   jresult = (unsigned long)result;
20764   return jresult;
20765 }
20766
20767
20768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20769   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20770
20771   arg1 = (Dali::VectorBase *)jarg1;
20772   {
20773     try {
20774       (arg1)->Release();
20775     } catch (std::out_of_range& e) {
20776       {
20777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20778       };
20779     } catch (std::exception& e) {
20780       {
20781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20786       };
20787     }
20788   }
20789 }
20790
20791
20792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20793   void * jresult ;
20794   Dali::Image *result = 0 ;
20795
20796   {
20797     try {
20798       result = (Dali::Image *)new Dali::Image();
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (...) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20810       };
20811     }
20812   }
20813   jresult = (void *)result;
20814   return jresult;
20815 }
20816
20817
20818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20819   Dali::Image *arg1 = (Dali::Image *) 0 ;
20820
20821   arg1 = (Dali::Image *)jarg1;
20822   {
20823     try {
20824       delete arg1;
20825     } catch (std::out_of_range& e) {
20826       {
20827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20828       };
20829     } catch (std::exception& e) {
20830       {
20831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20832       };
20833     } catch (...) {
20834       {
20835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20836       };
20837     }
20838   }
20839 }
20840
20841
20842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20843   void * jresult ;
20844   Dali::Image *arg1 = 0 ;
20845   Dali::Image *result = 0 ;
20846
20847   arg1 = (Dali::Image *)jarg1;
20848   if (!arg1) {
20849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20850     return 0;
20851   }
20852   {
20853     try {
20854       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20855     } catch (std::out_of_range& e) {
20856       {
20857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (std::exception& e) {
20860       {
20861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20862       };
20863     } catch (...) {
20864       {
20865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20866       };
20867     }
20868   }
20869   jresult = (void *)result;
20870   return jresult;
20871 }
20872
20873
20874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20875   void * jresult ;
20876   Dali::Image *arg1 = (Dali::Image *) 0 ;
20877   Dali::Image *arg2 = 0 ;
20878   Dali::Image *result = 0 ;
20879
20880   arg1 = (Dali::Image *)jarg1;
20881   arg2 = (Dali::Image *)jarg2;
20882   if (!arg2) {
20883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20884     return 0;
20885   }
20886   {
20887     try {
20888       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20889     } catch (std::out_of_range& e) {
20890       {
20891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20892       };
20893     } catch (std::exception& e) {
20894       {
20895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20896       };
20897     } catch (...) {
20898       {
20899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20900       };
20901     }
20902   }
20903   jresult = (void *)result;
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20909   void * jresult ;
20910   Dali::BaseHandle arg1 ;
20911   Dali::BaseHandle *argp1 ;
20912   Dali::Image result;
20913
20914   argp1 = (Dali::BaseHandle *)jarg1;
20915   if (!argp1) {
20916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20917     return 0;
20918   }
20919   arg1 = *argp1;
20920   {
20921     try {
20922       result = Dali::Image::DownCast(arg1);
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937   jresult = new Dali::Image((const Dali::Image &)result);
20938   return jresult;
20939 }
20940
20941
20942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20943   unsigned int jresult ;
20944   Dali::Image *arg1 = (Dali::Image *) 0 ;
20945   unsigned int result;
20946
20947   arg1 = (Dali::Image *)jarg1;
20948   {
20949     try {
20950       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20951     } catch (std::out_of_range& e) {
20952       {
20953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20954       };
20955     } catch (std::exception& e) {
20956       {
20957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (...) {
20960       {
20961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20962       };
20963     }
20964   }
20965   jresult = result;
20966   return jresult;
20967 }
20968
20969
20970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20971   unsigned int jresult ;
20972   Dali::Image *arg1 = (Dali::Image *) 0 ;
20973   unsigned int result;
20974
20975   arg1 = (Dali::Image *)jarg1;
20976   {
20977     try {
20978       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20979     } catch (std::out_of_range& e) {
20980       {
20981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20982       };
20983     } catch (std::exception& e) {
20984       {
20985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (...) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20990       };
20991     }
20992   }
20993   jresult = result;
20994   return jresult;
20995 }
20996
20997
20998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20999   void * jresult ;
21000   Dali::Image *arg1 = (Dali::Image *) 0 ;
21001   Dali::Image::ImageSignalType *result = 0 ;
21002
21003   arg1 = (Dali::Image *)jarg1;
21004   {
21005     try {
21006       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21007     } catch (std::out_of_range& e) {
21008       {
21009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (std::exception& e) {
21012       {
21013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (...) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21018       };
21019     }
21020   }
21021   jresult = (void *)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21027   int jresult ;
21028   Dali::Pixel::Format result;
21029
21030   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21031   jresult = (int)result;
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21037   int jresult ;
21038   Dali::Pixel::Format result;
21039
21040   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21041   jresult = (int)result;
21042   return jresult;
21043 }
21044
21045
21046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21047   unsigned int jresult ;
21048   Dali::Pixel::Format arg1 ;
21049   bool result;
21050
21051   arg1 = (Dali::Pixel::Format)jarg1;
21052   {
21053     try {
21054       result = (bool)Dali::Pixel::HasAlpha(arg1);
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (...) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21066       };
21067     }
21068   }
21069   jresult = result;
21070   return jresult;
21071 }
21072
21073
21074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21075   unsigned int jresult ;
21076   Dali::Pixel::Format arg1 ;
21077   unsigned int result;
21078
21079   arg1 = (Dali::Pixel::Format)jarg1;
21080   {
21081     try {
21082       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21094       };
21095     }
21096   }
21097   jresult = result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21103   Dali::Pixel::Format arg1 ;
21104   int *arg2 = 0 ;
21105   int *arg3 = 0 ;
21106
21107   arg1 = (Dali::Pixel::Format)jarg1;
21108   arg2 = (int *)jarg2;
21109   if (!arg2) {
21110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21111     return ;
21112   }
21113   arg3 = (int *)jarg3;
21114   if (!arg3) {
21115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21116     return ;
21117   }
21118   {
21119     try {
21120       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21121     } catch (std::out_of_range& e) {
21122       {
21123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21124       };
21125     } catch (std::exception& e) {
21126       {
21127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21128       };
21129     } catch (...) {
21130       {
21131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21132       };
21133     }
21134   }
21135 }
21136
21137
21138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21139   void * jresult ;
21140   unsigned char *arg1 = (unsigned char *) 0 ;
21141   unsigned int arg2 ;
21142   unsigned int arg3 ;
21143   unsigned int arg4 ;
21144   Dali::Pixel::Format arg5 ;
21145   Dali::PixelData::ReleaseFunction arg6 ;
21146   Dali::PixelData result;
21147
21148   arg1 = jarg1;
21149   arg2 = (unsigned int)jarg2;
21150   arg3 = (unsigned int)jarg3;
21151   arg4 = (unsigned int)jarg4;
21152   arg5 = (Dali::Pixel::Format)jarg5;
21153   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21154   {
21155     try {
21156       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21157     } catch (std::out_of_range& e) {
21158       {
21159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21160       };
21161     } catch (std::exception& e) {
21162       {
21163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21168       };
21169     }
21170   }
21171   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21172
21173
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21179   void * jresult ;
21180   Dali::PixelData *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::PixelData *)new Dali::PixelData();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (...) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21196       };
21197     }
21198   }
21199   jresult = (void *)result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21205   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21206
21207   arg1 = (Dali::PixelData *)jarg1;
21208   {
21209     try {
21210       delete arg1;
21211     } catch (std::out_of_range& e) {
21212       {
21213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21214       };
21215     } catch (std::exception& e) {
21216       {
21217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (...) {
21220       {
21221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21222       };
21223     }
21224   }
21225 }
21226
21227
21228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21229   void * jresult ;
21230   Dali::PixelData *arg1 = 0 ;
21231   Dali::PixelData *result = 0 ;
21232
21233   arg1 = (Dali::PixelData *)jarg1;
21234   if (!arg1) {
21235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21236     return 0;
21237   }
21238   {
21239     try {
21240       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21241     } catch (std::out_of_range& e) {
21242       {
21243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21244       };
21245     } catch (std::exception& e) {
21246       {
21247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21248       };
21249     } catch (...) {
21250       {
21251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21252       };
21253     }
21254   }
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21261   void * jresult ;
21262   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21263   Dali::PixelData *arg2 = 0 ;
21264   Dali::PixelData *result = 0 ;
21265
21266   arg1 = (Dali::PixelData *)jarg1;
21267   arg2 = (Dali::PixelData *)jarg2;
21268   if (!arg2) {
21269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21270     return 0;
21271   }
21272   {
21273     try {
21274       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21275     } catch (std::out_of_range& e) {
21276       {
21277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (std::exception& e) {
21280       {
21281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289   jresult = (void *)result;
21290   return jresult;
21291 }
21292
21293
21294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21295   unsigned int jresult ;
21296   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21297   unsigned int result;
21298
21299   arg1 = (Dali::PixelData *)jarg1;
21300   {
21301     try {
21302       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21303     } catch (std::out_of_range& e) {
21304       {
21305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21306       };
21307     } catch (std::exception& e) {
21308       {
21309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21310       };
21311     } catch (...) {
21312       {
21313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21314       };
21315     }
21316   }
21317   jresult = result;
21318   return jresult;
21319 }
21320
21321
21322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21323   unsigned int jresult ;
21324   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21325   unsigned int result;
21326
21327   arg1 = (Dali::PixelData *)jarg1;
21328   {
21329     try {
21330       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21331     } catch (std::out_of_range& e) {
21332       {
21333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21334       };
21335     } catch (std::exception& e) {
21336       {
21337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21338       };
21339     } catch (...) {
21340       {
21341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21342       };
21343     }
21344   }
21345   jresult = result;
21346   return jresult;
21347 }
21348
21349
21350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21351   int jresult ;
21352   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21353   Dali::Pixel::Format result;
21354
21355   arg1 = (Dali::PixelData *)jarg1;
21356   {
21357     try {
21358       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21359     } catch (std::out_of_range& e) {
21360       {
21361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (std::exception& e) {
21364       {
21365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21366       };
21367     } catch (...) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21370       };
21371     }
21372   }
21373   jresult = (int)result;
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21379   unsigned int jresult ;
21380   unsigned int result;
21381
21382   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21389   unsigned int jresult ;
21390   unsigned int result;
21391
21392   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21393   jresult = result;
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21399   unsigned int jresult ;
21400   unsigned int result;
21401
21402   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21403   jresult = result;
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21409   unsigned int jresult ;
21410   unsigned int result;
21411
21412   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21413   jresult = result;
21414   return jresult;
21415 }
21416
21417
21418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21419   unsigned int jresult ;
21420   unsigned int result;
21421
21422   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21423   jresult = result;
21424   return jresult;
21425 }
21426
21427
21428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21429   unsigned int jresult ;
21430   unsigned int result;
21431
21432   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21433   jresult = result;
21434   return jresult;
21435 }
21436
21437
21438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21439   void * jresult ;
21440   Dali::TextureType::Type arg1 ;
21441   Dali::Pixel::Format arg2 ;
21442   unsigned int arg3 ;
21443   unsigned int arg4 ;
21444   Dali::Texture result;
21445
21446   arg1 = (Dali::TextureType::Type)jarg1;
21447   arg2 = (Dali::Pixel::Format)jarg2;
21448   arg3 = (unsigned int)jarg3;
21449   arg4 = (unsigned int)jarg4;
21450   {
21451     try {
21452       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21464       };
21465     }
21466   }
21467   jresult = new Dali::Texture((const Dali::Texture &)result);
21468   return jresult;
21469 }
21470
21471
21472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21473   void * jresult ;
21474   NativeImageInterface *arg1 = 0 ;
21475   Dali::Texture result;
21476
21477   arg1 = (NativeImageInterface *)jarg1;
21478   if (!arg1) {
21479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21480     return 0;
21481   }
21482   {
21483     try {
21484       result = Dali::Texture::New(*arg1);
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (...) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21496       };
21497     }
21498   }
21499   jresult = new Dali::Texture((const Dali::Texture &)result);
21500   return jresult;
21501 }
21502
21503
21504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21505   void * jresult ;
21506   Dali::Texture *result = 0 ;
21507
21508   {
21509     try {
21510       result = (Dali::Texture *)new Dali::Texture();
21511     } catch (std::out_of_range& e) {
21512       {
21513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (std::exception& e) {
21516       {
21517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21518       };
21519     } catch (...) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21522       };
21523     }
21524   }
21525   jresult = (void *)result;
21526   return jresult;
21527 }
21528
21529
21530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21531   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21532
21533   arg1 = (Dali::Texture *)jarg1;
21534   {
21535     try {
21536       delete arg1;
21537     } catch (std::out_of_range& e) {
21538       {
21539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21540       };
21541     } catch (std::exception& e) {
21542       {
21543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21544       };
21545     } catch (...) {
21546       {
21547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21548       };
21549     }
21550   }
21551 }
21552
21553
21554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21555   void * jresult ;
21556   Dali::Texture *arg1 = 0 ;
21557   Dali::Texture *result = 0 ;
21558
21559   arg1 = (Dali::Texture *)jarg1;
21560   if (!arg1) {
21561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21562     return 0;
21563   }
21564   {
21565     try {
21566       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21567     } catch (std::out_of_range& e) {
21568       {
21569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21570       };
21571     } catch (std::exception& e) {
21572       {
21573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (...) {
21576       {
21577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21578       };
21579     }
21580   }
21581   jresult = (void *)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21587   void * jresult ;
21588   Dali::BaseHandle arg1 ;
21589   Dali::BaseHandle *argp1 ;
21590   Dali::Texture result;
21591
21592   argp1 = (Dali::BaseHandle *)jarg1;
21593   if (!argp1) {
21594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21595     return 0;
21596   }
21597   arg1 = *argp1;
21598   {
21599     try {
21600       result = Dali::Texture::DownCast(arg1);
21601     } catch (std::out_of_range& e) {
21602       {
21603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (std::exception& e) {
21606       {
21607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21608       };
21609     } catch (...) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21612       };
21613     }
21614   }
21615   jresult = new Dali::Texture((const Dali::Texture &)result);
21616   return jresult;
21617 }
21618
21619
21620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21621   void * jresult ;
21622   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21623   Dali::Texture *arg2 = 0 ;
21624   Dali::Texture *result = 0 ;
21625
21626   arg1 = (Dali::Texture *)jarg1;
21627   arg2 = (Dali::Texture *)jarg2;
21628   if (!arg2) {
21629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21630     return 0;
21631   }
21632   {
21633     try {
21634       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21635     } catch (std::out_of_range& e) {
21636       {
21637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21638       };
21639     } catch (std::exception& e) {
21640       {
21641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21642       };
21643     } catch (...) {
21644       {
21645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21646       };
21647     }
21648   }
21649   jresult = (void *)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21655   unsigned int jresult ;
21656   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21657   Dali::PixelData arg2 ;
21658   Dali::PixelData *argp2 ;
21659   bool result;
21660
21661   arg1 = (Dali::Texture *)jarg1;
21662   argp2 = (Dali::PixelData *)jarg2;
21663   if (!argp2) {
21664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21665     return 0;
21666   }
21667   arg2 = *argp2;
21668   {
21669     try {
21670       result = (bool)(arg1)->Upload(arg2);
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21682       };
21683     }
21684   }
21685   jresult = result;
21686   return jresult;
21687 }
21688
21689
21690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
21691   unsigned int jresult ;
21692   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21693   Dali::PixelData arg2 ;
21694   unsigned int arg3 ;
21695   unsigned int arg4 ;
21696   unsigned int arg5 ;
21697   unsigned int arg6 ;
21698   unsigned int arg7 ;
21699   unsigned int arg8 ;
21700   Dali::PixelData *argp2 ;
21701   bool result;
21702
21703   arg1 = (Dali::Texture *)jarg1;
21704   argp2 = (Dali::PixelData *)jarg2;
21705   if (!argp2) {
21706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21707     return 0;
21708   }
21709   arg2 = *argp2;
21710   arg3 = (unsigned int)jarg3;
21711   arg4 = (unsigned int)jarg4;
21712   arg5 = (unsigned int)jarg5;
21713   arg6 = (unsigned int)jarg6;
21714   arg7 = (unsigned int)jarg7;
21715   arg8 = (unsigned int)jarg8;
21716   {
21717     try {
21718       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21726       };
21727     } catch (...) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21730       };
21731     }
21732   }
21733   jresult = result;
21734   return jresult;
21735 }
21736
21737
21738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21739   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21740
21741   arg1 = (Dali::Texture *)jarg1;
21742   {
21743     try {
21744       (arg1)->GenerateMipmaps();
21745     } catch (std::out_of_range& e) {
21746       {
21747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21748       };
21749     } catch (std::exception& e) {
21750       {
21751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21756       };
21757     }
21758   }
21759 }
21760
21761
21762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21763   unsigned int jresult ;
21764   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21765   unsigned int result;
21766
21767   arg1 = (Dali::Texture *)jarg1;
21768   {
21769     try {
21770       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21771     } catch (std::out_of_range& e) {
21772       {
21773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (std::exception& e) {
21776       {
21777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (...) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21782       };
21783     }
21784   }
21785   jresult = result;
21786   return jresult;
21787 }
21788
21789
21790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21791   unsigned int jresult ;
21792   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21793   unsigned int result;
21794
21795   arg1 = (Dali::Texture *)jarg1;
21796   {
21797     try {
21798       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21799     } catch (std::out_of_range& e) {
21800       {
21801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (std::exception& e) {
21804       {
21805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813   jresult = result;
21814   return jresult;
21815 }
21816
21817
21818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21819   void * jresult ;
21820   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21821   Dali::Texture *result = 0 ;
21822
21823   arg1 = (Dali::Internal::Texture *)jarg1;
21824   {
21825     try {
21826       result = (Dali::Texture *)new Dali::Texture(arg1);
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (...) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21838       };
21839     }
21840   }
21841   jresult = (void *)result;
21842   return jresult;
21843 }
21844
21845
21846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21847   void * jresult ;
21848   Dali::Sampler result;
21849
21850   {
21851     try {
21852       result = Dali::Sampler::New();
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21868   return jresult;
21869 }
21870
21871
21872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21873   void * jresult ;
21874   Dali::Sampler *result = 0 ;
21875
21876   {
21877     try {
21878       result = (Dali::Sampler *)new Dali::Sampler();
21879     } catch (std::out_of_range& e) {
21880       {
21881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (std::exception& e) {
21884       {
21885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893   jresult = (void *)result;
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21899   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21900
21901   arg1 = (Dali::Sampler *)jarg1;
21902   {
21903     try {
21904       delete arg1;
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21912       };
21913     } catch (...) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21916       };
21917     }
21918   }
21919 }
21920
21921
21922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21923   void * jresult ;
21924   Dali::Sampler *arg1 = 0 ;
21925   Dali::Sampler *result = 0 ;
21926
21927   arg1 = (Dali::Sampler *)jarg1;
21928   if (!arg1) {
21929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21930     return 0;
21931   }
21932   {
21933     try {
21934       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21935     } catch (std::out_of_range& e) {
21936       {
21937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (std::exception& e) {
21940       {
21941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21942       };
21943     } catch (...) {
21944       {
21945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21946       };
21947     }
21948   }
21949   jresult = (void *)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21955   void * jresult ;
21956   Dali::BaseHandle arg1 ;
21957   Dali::BaseHandle *argp1 ;
21958   Dali::Sampler result;
21959
21960   argp1 = (Dali::BaseHandle *)jarg1;
21961   if (!argp1) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21963     return 0;
21964   }
21965   arg1 = *argp1;
21966   {
21967     try {
21968       result = Dali::Sampler::DownCast(arg1);
21969     } catch (std::out_of_range& e) {
21970       {
21971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (std::exception& e) {
21974       {
21975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21976       };
21977     } catch (...) {
21978       {
21979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21980       };
21981     }
21982   }
21983   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21989   void * jresult ;
21990   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21991   Dali::Sampler *arg2 = 0 ;
21992   Dali::Sampler *result = 0 ;
21993
21994   arg1 = (Dali::Sampler *)jarg1;
21995   arg2 = (Dali::Sampler *)jarg2;
21996   if (!arg2) {
21997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21998     return 0;
21999   }
22000   {
22001     try {
22002       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22003     } catch (std::out_of_range& e) {
22004       {
22005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (std::exception& e) {
22008       {
22009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017   jresult = (void *)result;
22018   return jresult;
22019 }
22020
22021
22022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22023   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22024   Dali::FilterMode::Type arg2 ;
22025   Dali::FilterMode::Type arg3 ;
22026
22027   arg1 = (Dali::Sampler *)jarg1;
22028   arg2 = (Dali::FilterMode::Type)jarg2;
22029   arg3 = (Dali::FilterMode::Type)jarg3;
22030   {
22031     try {
22032       (arg1)->SetFilterMode(arg2,arg3);
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22040       };
22041     } catch (...) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22044       };
22045     }
22046   }
22047 }
22048
22049
22050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22051   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22052   Dali::WrapMode::Type arg2 ;
22053   Dali::WrapMode::Type arg3 ;
22054
22055   arg1 = (Dali::Sampler *)jarg1;
22056   arg2 = (Dali::WrapMode::Type)jarg2;
22057   arg3 = (Dali::WrapMode::Type)jarg3;
22058   {
22059     try {
22060       (arg1)->SetWrapMode(arg2,arg3);
22061     } catch (std::out_of_range& e) {
22062       {
22063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22064       };
22065     } catch (std::exception& e) {
22066       {
22067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22072       };
22073     }
22074   }
22075 }
22076
22077
22078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22079   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22080   Dali::WrapMode::Type arg2 ;
22081   Dali::WrapMode::Type arg3 ;
22082   Dali::WrapMode::Type arg4 ;
22083
22084   arg1 = (Dali::Sampler *)jarg1;
22085   arg2 = (Dali::WrapMode::Type)jarg2;
22086   arg3 = (Dali::WrapMode::Type)jarg3;
22087   arg4 = (Dali::WrapMode::Type)jarg4;
22088   {
22089     try {
22090       (arg1)->SetWrapMode(arg2,arg3,arg4);
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22098       };
22099     } catch (...) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22102       };
22103     }
22104   }
22105 }
22106
22107
22108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22109   void * jresult ;
22110   Dali::TextureSet result;
22111
22112   {
22113     try {
22114       result = Dali::TextureSet::New();
22115     } catch (std::out_of_range& e) {
22116       {
22117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22118       };
22119     } catch (std::exception& e) {
22120       {
22121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (...) {
22124       {
22125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22126       };
22127     }
22128   }
22129   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22130   return jresult;
22131 }
22132
22133
22134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22135   void * jresult ;
22136   Dali::TextureSet *result = 0 ;
22137
22138   {
22139     try {
22140       result = (Dali::TextureSet *)new Dali::TextureSet();
22141     } catch (std::out_of_range& e) {
22142       {
22143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (std::exception& e) {
22146       {
22147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155   jresult = (void *)result;
22156   return jresult;
22157 }
22158
22159
22160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22161   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22162
22163   arg1 = (Dali::TextureSet *)jarg1;
22164   {
22165     try {
22166       delete arg1;
22167     } catch (std::out_of_range& e) {
22168       {
22169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22170       };
22171     } catch (std::exception& e) {
22172       {
22173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22174       };
22175     } catch (...) {
22176       {
22177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22178       };
22179     }
22180   }
22181 }
22182
22183
22184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22185   void * jresult ;
22186   Dali::TextureSet *arg1 = 0 ;
22187   Dali::TextureSet *result = 0 ;
22188
22189   arg1 = (Dali::TextureSet *)jarg1;
22190   if (!arg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22192     return 0;
22193   }
22194   {
22195     try {
22196       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22197     } catch (std::out_of_range& e) {
22198       {
22199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22200       };
22201     } catch (std::exception& e) {
22202       {
22203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22204       };
22205     } catch (...) {
22206       {
22207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22208       };
22209     }
22210   }
22211   jresult = (void *)result;
22212   return jresult;
22213 }
22214
22215
22216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22217   void * jresult ;
22218   Dali::BaseHandle arg1 ;
22219   Dali::BaseHandle *argp1 ;
22220   Dali::TextureSet result;
22221
22222   argp1 = (Dali::BaseHandle *)jarg1;
22223   if (!argp1) {
22224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22225     return 0;
22226   }
22227   arg1 = *argp1;
22228   {
22229     try {
22230       result = Dali::TextureSet::DownCast(arg1);
22231     } catch (std::out_of_range& e) {
22232       {
22233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22234       };
22235     } catch (std::exception& e) {
22236       {
22237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22242       };
22243     }
22244   }
22245   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22246   return jresult;
22247 }
22248
22249
22250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22251   void * jresult ;
22252   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22253   Dali::TextureSet *arg2 = 0 ;
22254   Dali::TextureSet *result = 0 ;
22255
22256   arg1 = (Dali::TextureSet *)jarg1;
22257   arg2 = (Dali::TextureSet *)jarg2;
22258   if (!arg2) {
22259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22260     return 0;
22261   }
22262   {
22263     try {
22264       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22265     } catch (std::out_of_range& e) {
22266       {
22267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22268       };
22269     } catch (std::exception& e) {
22270       {
22271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22276       };
22277     }
22278   }
22279   jresult = (void *)result;
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22285   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22286   size_t arg2 ;
22287   Dali::Texture arg3 ;
22288   Dali::Texture *argp3 ;
22289
22290   arg1 = (Dali::TextureSet *)jarg1;
22291   arg2 = (size_t)jarg2;
22292   argp3 = (Dali::Texture *)jarg3;
22293   if (!argp3) {
22294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22295     return ;
22296   }
22297   arg3 = *argp3;
22298   {
22299     try {
22300       (arg1)->SetTexture(arg2,arg3);
22301     } catch (std::out_of_range& e) {
22302       {
22303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22304       };
22305     } catch (std::exception& e) {
22306       {
22307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22308       };
22309     } catch (...) {
22310       {
22311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22312       };
22313     }
22314   }
22315 }
22316
22317
22318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22319   void * jresult ;
22320   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22321   size_t arg2 ;
22322   Dali::Texture result;
22323
22324   arg1 = (Dali::TextureSet *)jarg1;
22325   arg2 = (size_t)jarg2;
22326   {
22327     try {
22328       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22329     } catch (std::out_of_range& e) {
22330       {
22331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22332       };
22333     } catch (std::exception& e) {
22334       {
22335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22336       };
22337     } catch (...) {
22338       {
22339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22340       };
22341     }
22342   }
22343   jresult = new Dali::Texture((const Dali::Texture &)result);
22344   return jresult;
22345 }
22346
22347
22348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22349   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22350   size_t arg2 ;
22351   Dali::Sampler arg3 ;
22352   Dali::Sampler *argp3 ;
22353
22354   arg1 = (Dali::TextureSet *)jarg1;
22355   arg2 = (size_t)jarg2;
22356   argp3 = (Dali::Sampler *)jarg3;
22357   if (!argp3) {
22358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22359     return ;
22360   }
22361   arg3 = *argp3;
22362   {
22363     try {
22364       (arg1)->SetSampler(arg2,arg3);
22365     } catch (std::out_of_range& e) {
22366       {
22367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22368       };
22369     } catch (std::exception& e) {
22370       {
22371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22372       };
22373     } catch (...) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22376       };
22377     }
22378   }
22379 }
22380
22381
22382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22383   void * jresult ;
22384   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22385   size_t arg2 ;
22386   Dali::Sampler result;
22387
22388   arg1 = (Dali::TextureSet *)jarg1;
22389   arg2 = (size_t)jarg2;
22390   {
22391     try {
22392       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22393     } catch (std::out_of_range& e) {
22394       {
22395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22396       };
22397     } catch (std::exception& e) {
22398       {
22399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (...) {
22402       {
22403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22404       };
22405     }
22406   }
22407   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22408   return jresult;
22409 }
22410
22411
22412 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22413   unsigned long jresult ;
22414   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22415   size_t result;
22416
22417   arg1 = (Dali::TextureSet *)jarg1;
22418   {
22419     try {
22420       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22432       };
22433     }
22434   }
22435   jresult = (unsigned long)result;
22436   return jresult;
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22441   void * jresult ;
22442   Dali::Property::Map *arg1 = 0 ;
22443   Dali::PropertyBuffer result;
22444
22445   arg1 = (Dali::Property::Map *)jarg1;
22446   if (!arg1) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22448     return 0;
22449   }
22450   {
22451     try {
22452       result = Dali::PropertyBuffer::New(*arg1);
22453     } catch (std::out_of_range& e) {
22454       {
22455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22456       };
22457     } catch (std::exception& e) {
22458       {
22459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22460       };
22461     } catch (...) {
22462       {
22463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22464       };
22465     }
22466   }
22467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22473   void * jresult ;
22474   Dali::PropertyBuffer *result = 0 ;
22475
22476   {
22477     try {
22478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22479     } catch (std::out_of_range& e) {
22480       {
22481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (std::exception& e) {
22484       {
22485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493   jresult = (void *)result;
22494   return jresult;
22495 }
22496
22497
22498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22499   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22500
22501   arg1 = (Dali::PropertyBuffer *)jarg1;
22502   {
22503     try {
22504       delete arg1;
22505     } catch (std::out_of_range& e) {
22506       {
22507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22508       };
22509     } catch (std::exception& e) {
22510       {
22511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22516       };
22517     }
22518   }
22519 }
22520
22521
22522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22523   void * jresult ;
22524   Dali::PropertyBuffer *arg1 = 0 ;
22525   Dali::PropertyBuffer *result = 0 ;
22526
22527   arg1 = (Dali::PropertyBuffer *)jarg1;
22528   if (!arg1) {
22529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22530     return 0;
22531   }
22532   {
22533     try {
22534       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22535     } catch (std::out_of_range& e) {
22536       {
22537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22538       };
22539     } catch (std::exception& e) {
22540       {
22541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22542       };
22543     } catch (...) {
22544       {
22545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22546       };
22547     }
22548   }
22549   jresult = (void *)result;
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22555   void * jresult ;
22556   Dali::BaseHandle arg1 ;
22557   Dali::BaseHandle *argp1 ;
22558   Dali::PropertyBuffer result;
22559
22560   argp1 = (Dali::BaseHandle *)jarg1;
22561   if (!argp1) {
22562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22563     return 0;
22564   }
22565   arg1 = *argp1;
22566   {
22567     try {
22568       result = Dali::PropertyBuffer::DownCast(arg1);
22569     } catch (std::out_of_range& e) {
22570       {
22571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22572       };
22573     } catch (std::exception& e) {
22574       {
22575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22576       };
22577     } catch (...) {
22578       {
22579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22580       };
22581     }
22582   }
22583   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22584   return jresult;
22585 }
22586
22587
22588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22589   void * jresult ;
22590   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22591   Dali::PropertyBuffer *arg2 = 0 ;
22592   Dali::PropertyBuffer *result = 0 ;
22593
22594   arg1 = (Dali::PropertyBuffer *)jarg1;
22595   arg2 = (Dali::PropertyBuffer *)jarg2;
22596   if (!arg2) {
22597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22598     return 0;
22599   }
22600   {
22601     try {
22602       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (...) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22614       };
22615     }
22616   }
22617   jresult = (void *)result;
22618   return jresult;
22619 }
22620
22621
22622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22623   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22624   void *arg2 = (void *) 0 ;
22625   std::size_t arg3 ;
22626
22627   arg1 = (Dali::PropertyBuffer *)jarg1;
22628   arg2 = jarg2;
22629   arg3 = (std::size_t)jarg3;
22630   {
22631     try {
22632       (arg1)->SetData((void const *)arg2,arg3);
22633     } catch (std::out_of_range& e) {
22634       {
22635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22636       };
22637     } catch (std::exception& e) {
22638       {
22639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (...) {
22642       {
22643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22644       };
22645     }
22646   }
22647 }
22648
22649
22650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22651   unsigned long jresult ;
22652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22653   std::size_t result;
22654
22655   arg1 = (Dali::PropertyBuffer *)jarg1;
22656   {
22657     try {
22658       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22659     } catch (std::out_of_range& e) {
22660       {
22661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22662       };
22663     } catch (std::exception& e) {
22664       {
22665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22666       };
22667     } catch (...) {
22668       {
22669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22670       };
22671     }
22672   }
22673   jresult = (unsigned long)result;
22674   return jresult;
22675 }
22676
22677
22678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22679   void * jresult ;
22680   Dali::Geometry result;
22681
22682   {
22683     try {
22684       result = Dali::Geometry::New();
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (...) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22696       };
22697     }
22698   }
22699   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22705   void * jresult ;
22706   Dali::Geometry *result = 0 ;
22707
22708   {
22709     try {
22710       result = (Dali::Geometry *)new Dali::Geometry();
22711     } catch (std::out_of_range& e) {
22712       {
22713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22714       };
22715     } catch (std::exception& e) {
22716       {
22717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22718       };
22719     } catch (...) {
22720       {
22721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22722       };
22723     }
22724   }
22725   jresult = (void *)result;
22726   return jresult;
22727 }
22728
22729
22730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22731   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22732
22733   arg1 = (Dali::Geometry *)jarg1;
22734   {
22735     try {
22736       delete arg1;
22737     } catch (std::out_of_range& e) {
22738       {
22739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22740       };
22741     } catch (std::exception& e) {
22742       {
22743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22744       };
22745     } catch (...) {
22746       {
22747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22748       };
22749     }
22750   }
22751 }
22752
22753
22754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22755   void * jresult ;
22756   Dali::Geometry *arg1 = 0 ;
22757   Dali::Geometry *result = 0 ;
22758
22759   arg1 = (Dali::Geometry *)jarg1;
22760   if (!arg1) {
22761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22762     return 0;
22763   }
22764   {
22765     try {
22766       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (...) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22778       };
22779     }
22780   }
22781   jresult = (void *)result;
22782   return jresult;
22783 }
22784
22785
22786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22787   void * jresult ;
22788   Dali::BaseHandle arg1 ;
22789   Dali::BaseHandle *argp1 ;
22790   Dali::Geometry result;
22791
22792   argp1 = (Dali::BaseHandle *)jarg1;
22793   if (!argp1) {
22794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22795     return 0;
22796   }
22797   arg1 = *argp1;
22798   {
22799     try {
22800       result = Dali::Geometry::DownCast(arg1);
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22808       };
22809     } catch (...) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22812       };
22813     }
22814   }
22815   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22816   return jresult;
22817 }
22818
22819
22820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22821   void * jresult ;
22822   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22823   Dali::Geometry *arg2 = 0 ;
22824   Dali::Geometry *result = 0 ;
22825
22826   arg1 = (Dali::Geometry *)jarg1;
22827   arg2 = (Dali::Geometry *)jarg2;
22828   if (!arg2) {
22829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22830     return 0;
22831   }
22832   {
22833     try {
22834       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22835     } catch (std::out_of_range& e) {
22836       {
22837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22838       };
22839     } catch (std::exception& e) {
22840       {
22841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22842       };
22843     } catch (...) {
22844       {
22845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22846       };
22847     }
22848   }
22849   jresult = (void *)result;
22850   return jresult;
22851 }
22852
22853
22854 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22855   unsigned long jresult ;
22856   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22857   Dali::PropertyBuffer *arg2 = 0 ;
22858   std::size_t result;
22859
22860   arg1 = (Dali::Geometry *)jarg1;
22861   arg2 = (Dali::PropertyBuffer *)jarg2;
22862   if (!arg2) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22864     return 0;
22865   }
22866   {
22867     try {
22868       result = (arg1)->AddVertexBuffer(*arg2);
22869     } catch (std::out_of_range& e) {
22870       {
22871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22872       };
22873     } catch (std::exception& e) {
22874       {
22875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22876       };
22877     } catch (...) {
22878       {
22879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22880       };
22881     }
22882   }
22883   jresult = (unsigned long)result;
22884   return jresult;
22885 }
22886
22887
22888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22889   unsigned long jresult ;
22890   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22891   std::size_t result;
22892
22893   arg1 = (Dali::Geometry *)jarg1;
22894   {
22895     try {
22896       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (...) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22908       };
22909     }
22910   }
22911   jresult = (unsigned long)result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22918   std::size_t arg2 ;
22919
22920   arg1 = (Dali::Geometry *)jarg1;
22921   arg2 = (std::size_t)jarg2;
22922   {
22923     try {
22924       (arg1)->RemoveVertexBuffer(arg2);
22925     } catch (std::out_of_range& e) {
22926       {
22927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22928       };
22929     } catch (std::exception& e) {
22930       {
22931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22932       };
22933     } catch (...) {
22934       {
22935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22936       };
22937     }
22938   }
22939 }
22940
22941
22942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22943   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22944   unsigned short *arg2 = (unsigned short *) 0 ;
22945   size_t arg3 ;
22946
22947   arg1 = (Dali::Geometry *)jarg1;
22948   arg2 = jarg2;
22949   arg3 = (size_t)jarg3;
22950   {
22951     try {
22952       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22953     } catch (std::out_of_range& e) {
22954       {
22955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22956       };
22957     } catch (std::exception& e) {
22958       {
22959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22960       };
22961     } catch (...) {
22962       {
22963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22964       };
22965     }
22966   }
22967
22968
22969 }
22970
22971
22972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22973   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22974   Dali::Geometry::Type arg2 ;
22975
22976   arg1 = (Dali::Geometry *)jarg1;
22977   arg2 = (Dali::Geometry::Type)jarg2;
22978   {
22979     try {
22980       (arg1)->SetType(arg2);
22981     } catch (std::out_of_range& e) {
22982       {
22983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22984       };
22985     } catch (std::exception& e) {
22986       {
22987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22988       };
22989     } catch (...) {
22990       {
22991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22992       };
22993     }
22994   }
22995 }
22996
22997
22998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22999   int jresult ;
23000   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
23001   Dali::Geometry::Type result;
23002
23003   arg1 = (Dali::Geometry *)jarg1;
23004   {
23005     try {
23006       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23007     } catch (std::out_of_range& e) {
23008       {
23009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23010       };
23011     } catch (std::exception& e) {
23012       {
23013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23014       };
23015     } catch (...) {
23016       {
23017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23018       };
23019     }
23020   }
23021   jresult = (int)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23027   void * jresult ;
23028   Dali::Shader::Hint *result = 0 ;
23029
23030   {
23031     try {
23032       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23033     } catch (std::out_of_range& e) {
23034       {
23035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23036       };
23037     } catch (std::exception& e) {
23038       {
23039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23040       };
23041     } catch (...) {
23042       {
23043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23044       };
23045     }
23046   }
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23053   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23054
23055   arg1 = (Dali::Shader::Hint *)jarg1;
23056   {
23057     try {
23058       delete arg1;
23059     } catch (std::out_of_range& e) {
23060       {
23061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23062       };
23063     } catch (std::exception& e) {
23064       {
23065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23066       };
23067     } catch (...) {
23068       {
23069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23070       };
23071     }
23072   }
23073 }
23074
23075
23076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23077   int jresult ;
23078   int result;
23079
23080   result = (int)Dali::Shader::Property::PROGRAM;
23081   jresult = (int)result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23087   void * jresult ;
23088   Dali::Shader::Property *result = 0 ;
23089
23090   {
23091     try {
23092       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23093     } catch (std::out_of_range& e) {
23094       {
23095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23096       };
23097     } catch (std::exception& e) {
23098       {
23099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23100       };
23101     } catch (...) {
23102       {
23103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23104       };
23105     }
23106   }
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23113   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23114
23115   arg1 = (Dali::Shader::Property *)jarg1;
23116   {
23117     try {
23118       delete arg1;
23119     } catch (std::out_of_range& e) {
23120       {
23121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23122       };
23123     } catch (std::exception& e) {
23124       {
23125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23126       };
23127     } catch (...) {
23128       {
23129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23130       };
23131     }
23132   }
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23137   void * jresult ;
23138   std::string *arg1 = 0 ;
23139   std::string *arg2 = 0 ;
23140   Dali::Shader::Hint::Value arg3 ;
23141   Dali::Shader result;
23142
23143   if (!jarg1) {
23144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23145     return 0;
23146   }
23147   std::string arg1_str(jarg1);
23148   arg1 = &arg1_str;
23149   if (!jarg2) {
23150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23151     return 0;
23152   }
23153   std::string arg2_str(jarg2);
23154   arg2 = &arg2_str;
23155   arg3 = (Dali::Shader::Hint::Value)jarg3;
23156   {
23157     try {
23158       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23159     } catch (std::out_of_range& e) {
23160       {
23161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23162       };
23163     } catch (std::exception& e) {
23164       {
23165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23166       };
23167     } catch (...) {
23168       {
23169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23170       };
23171     }
23172   }
23173   jresult = new Dali::Shader((const Dali::Shader &)result);
23174
23175   //argout typemap for const std::string&
23176
23177
23178   //argout typemap for const std::string&
23179
23180   return jresult;
23181 }
23182
23183
23184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23185   void * jresult ;
23186   std::string *arg1 = 0 ;
23187   std::string *arg2 = 0 ;
23188   Dali::Shader result;
23189
23190   if (!jarg1) {
23191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23192     return 0;
23193   }
23194   std::string arg1_str(jarg1);
23195   arg1 = &arg1_str;
23196   if (!jarg2) {
23197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23198     return 0;
23199   }
23200   std::string arg2_str(jarg2);
23201   arg2 = &arg2_str;
23202   {
23203     try {
23204       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23205     } catch (std::out_of_range& e) {
23206       {
23207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23208       };
23209     } catch (std::exception& e) {
23210       {
23211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23212       };
23213     } catch (...) {
23214       {
23215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23216       };
23217     }
23218   }
23219   jresult = new Dali::Shader((const Dali::Shader &)result);
23220
23221   //argout typemap for const std::string&
23222
23223
23224   //argout typemap for const std::string&
23225
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23231   void * jresult ;
23232   Dali::Shader *result = 0 ;
23233
23234   {
23235     try {
23236       result = (Dali::Shader *)new Dali::Shader();
23237     } catch (std::out_of_range& e) {
23238       {
23239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23240       };
23241     } catch (std::exception& e) {
23242       {
23243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23244       };
23245     } catch (...) {
23246       {
23247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23248       };
23249     }
23250   }
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23257   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23258
23259   arg1 = (Dali::Shader *)jarg1;
23260   {
23261     try {
23262       delete arg1;
23263     } catch (std::out_of_range& e) {
23264       {
23265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23266       };
23267     } catch (std::exception& e) {
23268       {
23269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23270       };
23271     } catch (...) {
23272       {
23273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23274       };
23275     }
23276   }
23277 }
23278
23279
23280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23281   void * jresult ;
23282   Dali::Shader *arg1 = 0 ;
23283   Dali::Shader *result = 0 ;
23284
23285   arg1 = (Dali::Shader *)jarg1;
23286   if (!arg1) {
23287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23288     return 0;
23289   }
23290   {
23291     try {
23292       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23293     } catch (std::out_of_range& e) {
23294       {
23295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23296       };
23297     } catch (std::exception& e) {
23298       {
23299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23300       };
23301     } catch (...) {
23302       {
23303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23304       };
23305     }
23306   }
23307   jresult = (void *)result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23313   void * jresult ;
23314   Dali::BaseHandle arg1 ;
23315   Dali::BaseHandle *argp1 ;
23316   Dali::Shader result;
23317
23318   argp1 = (Dali::BaseHandle *)jarg1;
23319   if (!argp1) {
23320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23321     return 0;
23322   }
23323   arg1 = *argp1;
23324   {
23325     try {
23326       result = Dali::Shader::DownCast(arg1);
23327     } catch (std::out_of_range& e) {
23328       {
23329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23330       };
23331     } catch (std::exception& e) {
23332       {
23333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23334       };
23335     } catch (...) {
23336       {
23337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23338       };
23339     }
23340   }
23341   jresult = new Dali::Shader((const Dali::Shader &)result);
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23347   void * jresult ;
23348   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23349   Dali::Shader *arg2 = 0 ;
23350   Dali::Shader *result = 0 ;
23351
23352   arg1 = (Dali::Shader *)jarg1;
23353   arg2 = (Dali::Shader *)jarg2;
23354   if (!arg2) {
23355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23356     return 0;
23357   }
23358   {
23359     try {
23360       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23361     } catch (std::out_of_range& e) {
23362       {
23363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23364       };
23365     } catch (std::exception& e) {
23366       {
23367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23368       };
23369     } catch (...) {
23370       {
23371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23372       };
23373     }
23374   }
23375   jresult = (void *)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::BLEND_MODE;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23521   int jresult ;
23522   int result;
23523
23524   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23525   jresult = (int)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23531   int jresult ;
23532   int result;
23533
23534   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23535   jresult = (int)result;
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23541   int jresult ;
23542   int result;
23543
23544   result = (int)Dali::Renderer::Property::RENDER_MODE;
23545   jresult = (int)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23551   int jresult ;
23552   int result;
23553
23554   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23555   jresult = (int)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23561   int jresult ;
23562   int result;
23563
23564   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23565   jresult = (int)result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23571   int jresult ;
23572   int result;
23573
23574   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23575   jresult = (int)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23581   int jresult ;
23582   int result;
23583
23584   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23591   int jresult ;
23592   int result;
23593
23594   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23601   int jresult ;
23602   int result;
23603
23604   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23605   jresult = (int)result;
23606   return jresult;
23607 }
23608
23609
23610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23611   int jresult ;
23612   int result;
23613
23614   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23615   jresult = (int)result;
23616   return jresult;
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23621   void * jresult ;
23622   Dali::Renderer::Property *result = 0 ;
23623
23624   {
23625     try {
23626       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23627     } catch (std::out_of_range& e) {
23628       {
23629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23630       };
23631     } catch (std::exception& e) {
23632       {
23633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (...) {
23636       {
23637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23638       };
23639     }
23640   }
23641   jresult = (void *)result;
23642   return jresult;
23643 }
23644
23645
23646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23647   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23648
23649   arg1 = (Dali::Renderer::Property *)jarg1;
23650   {
23651     try {
23652       delete arg1;
23653     } catch (std::out_of_range& e) {
23654       {
23655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23656       };
23657     } catch (std::exception& e) {
23658       {
23659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23660       };
23661     } catch (...) {
23662       {
23663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23664       };
23665     }
23666   }
23667 }
23668
23669
23670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23671   void * jresult ;
23672   Dali::Geometry *arg1 = 0 ;
23673   Dali::Shader *arg2 = 0 ;
23674   Dali::Renderer result;
23675
23676   arg1 = (Dali::Geometry *)jarg1;
23677   if (!arg1) {
23678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23679     return 0;
23680   }
23681   arg2 = (Dali::Shader *)jarg2;
23682   if (!arg2) {
23683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23684     return 0;
23685   }
23686   {
23687     try {
23688       result = Dali::Renderer::New(*arg1,*arg2);
23689     } catch (std::out_of_range& e) {
23690       {
23691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23692       };
23693     } catch (std::exception& e) {
23694       {
23695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23700       };
23701     }
23702   }
23703   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23704   return jresult;
23705 }
23706
23707
23708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23709   void * jresult ;
23710   Dali::Renderer *result = 0 ;
23711
23712   {
23713     try {
23714       result = (Dali::Renderer *)new Dali::Renderer();
23715     } catch (std::out_of_range& e) {
23716       {
23717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (std::exception& e) {
23720       {
23721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729   jresult = (void *)result;
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23735   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23736
23737   arg1 = (Dali::Renderer *)jarg1;
23738   {
23739     try {
23740       delete arg1;
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23748       };
23749     } catch (...) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23752       };
23753     }
23754   }
23755 }
23756
23757
23758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23759   void * jresult ;
23760   Dali::Renderer *arg1 = 0 ;
23761   Dali::Renderer *result = 0 ;
23762
23763   arg1 = (Dali::Renderer *)jarg1;
23764   if (!arg1) {
23765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23766     return 0;
23767   }
23768   {
23769     try {
23770       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23782       };
23783     }
23784   }
23785   jresult = (void *)result;
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23791   void * jresult ;
23792   Dali::BaseHandle arg1 ;
23793   Dali::BaseHandle *argp1 ;
23794   Dali::Renderer result;
23795
23796   argp1 = (Dali::BaseHandle *)jarg1;
23797   if (!argp1) {
23798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23799     return 0;
23800   }
23801   arg1 = *argp1;
23802   {
23803     try {
23804       result = Dali::Renderer::DownCast(arg1);
23805     } catch (std::out_of_range& e) {
23806       {
23807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23808       };
23809     } catch (std::exception& e) {
23810       {
23811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (...) {
23814       {
23815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23816       };
23817     }
23818   }
23819   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23820   return jresult;
23821 }
23822
23823
23824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23825   void * jresult ;
23826   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23827   Dali::Renderer *arg2 = 0 ;
23828   Dali::Renderer *result = 0 ;
23829
23830   arg1 = (Dali::Renderer *)jarg1;
23831   arg2 = (Dali::Renderer *)jarg2;
23832   if (!arg2) {
23833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23834     return 0;
23835   }
23836   {
23837     try {
23838       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23839     } catch (std::out_of_range& e) {
23840       {
23841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23842       };
23843     } catch (std::exception& e) {
23844       {
23845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (...) {
23848       {
23849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23850       };
23851     }
23852   }
23853   jresult = (void *)result;
23854   return jresult;
23855 }
23856
23857
23858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23859   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23860   Dali::Geometry *arg2 = 0 ;
23861
23862   arg1 = (Dali::Renderer *)jarg1;
23863   arg2 = (Dali::Geometry *)jarg2;
23864   if (!arg2) {
23865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23866     return ;
23867   }
23868   {
23869     try {
23870       (arg1)->SetGeometry(*arg2);
23871     } catch (std::out_of_range& e) {
23872       {
23873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23874       };
23875     } catch (std::exception& e) {
23876       {
23877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23878       };
23879     } catch (...) {
23880       {
23881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23882       };
23883     }
23884   }
23885 }
23886
23887
23888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23889   void * jresult ;
23890   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23891   Dali::Geometry result;
23892
23893   arg1 = (Dali::Renderer *)jarg1;
23894   {
23895     try {
23896       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23897     } catch (std::out_of_range& e) {
23898       {
23899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (std::exception& e) {
23902       {
23903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (...) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23908       };
23909     }
23910   }
23911   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23917   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23918   int arg2 ;
23919   int arg3 ;
23920
23921   arg1 = (Dali::Renderer *)jarg1;
23922   arg2 = (int)jarg2;
23923   arg3 = (int)jarg3;
23924   {
23925     try {
23926       (arg1)->SetIndexRange(arg2,arg3);
23927     } catch (std::out_of_range& e) {
23928       {
23929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23930       };
23931     } catch (std::exception& e) {
23932       {
23933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23934       };
23935     } catch (...) {
23936       {
23937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23938       };
23939     }
23940   }
23941 }
23942
23943
23944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23945   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23946   Dali::TextureSet *arg2 = 0 ;
23947
23948   arg1 = (Dali::Renderer *)jarg1;
23949   arg2 = (Dali::TextureSet *)jarg2;
23950   if (!arg2) {
23951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23952     return ;
23953   }
23954   {
23955     try {
23956       (arg1)->SetTextures(*arg2);
23957     } catch (std::out_of_range& e) {
23958       {
23959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23960       };
23961     } catch (std::exception& e) {
23962       {
23963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23964       };
23965     } catch (...) {
23966       {
23967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23968       };
23969     }
23970   }
23971 }
23972
23973
23974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23975   void * jresult ;
23976   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23977   Dali::TextureSet result;
23978
23979   arg1 = (Dali::Renderer *)jarg1;
23980   {
23981     try {
23982       result = ((Dali::Renderer const *)arg1)->GetTextures();
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24003   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24004   Dali::Shader *arg2 = 0 ;
24005
24006   arg1 = (Dali::Renderer *)jarg1;
24007   arg2 = (Dali::Shader *)jarg2;
24008   if (!arg2) {
24009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24010     return ;
24011   }
24012   {
24013     try {
24014       (arg1)->SetShader(*arg2);
24015     } catch (std::out_of_range& e) {
24016       {
24017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24018       };
24019     } catch (std::exception& e) {
24020       {
24021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24022       };
24023     } catch (...) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24026       };
24027     }
24028   }
24029 }
24030
24031
24032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24033   void * jresult ;
24034   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24035   Dali::Shader result;
24036
24037   arg1 = (Dali::Renderer *)jarg1;
24038   {
24039     try {
24040       result = ((Dali::Renderer const *)arg1)->GetShader();
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24048       };
24049     } catch (...) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24052       };
24053     }
24054   }
24055   jresult = new Dali::Shader((const Dali::Shader &)result);
24056   return jresult;
24057 }
24058
24059
24060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24061   void * jresult ;
24062   Dali::FrameBuffer::Attachment *result = 0 ;
24063
24064   {
24065     try {
24066       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24067     } catch (std::out_of_range& e) {
24068       {
24069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24070       };
24071     } catch (std::exception& e) {
24072       {
24073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24074       };
24075     } catch (...) {
24076       {
24077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24078       };
24079     }
24080   }
24081   jresult = (void *)result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24087   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24088
24089   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24090   {
24091     try {
24092       delete arg1;
24093     } catch (std::out_of_range& e) {
24094       {
24095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24096       };
24097     } catch (std::exception& e) {
24098       {
24099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24104       };
24105     }
24106   }
24107 }
24108
24109
24110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24111   void * jresult ;
24112   unsigned int arg1 ;
24113   unsigned int arg2 ;
24114   unsigned int arg3 ;
24115   Dali::FrameBuffer result;
24116
24117   arg1 = (unsigned int)jarg1;
24118   arg2 = (unsigned int)jarg2;
24119   arg3 = (unsigned int)jarg3;
24120   {
24121     try {
24122       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24123     } catch (std::out_of_range& e) {
24124       {
24125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (std::exception& e) {
24128       {
24129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24143   void * jresult ;
24144   Dali::FrameBuffer *result = 0 ;
24145
24146   {
24147     try {
24148       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24149     } catch (std::out_of_range& e) {
24150       {
24151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24152       };
24153     } catch (std::exception& e) {
24154       {
24155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (...) {
24158       {
24159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24160       };
24161     }
24162   }
24163   jresult = (void *)result;
24164   return jresult;
24165 }
24166
24167
24168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24169   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24170
24171   arg1 = (Dali::FrameBuffer *)jarg1;
24172   {
24173     try {
24174       delete arg1;
24175     } catch (std::out_of_range& e) {
24176       {
24177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24178       };
24179     } catch (std::exception& e) {
24180       {
24181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24182       };
24183     } catch (...) {
24184       {
24185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24186       };
24187     }
24188   }
24189 }
24190
24191
24192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24193   void * jresult ;
24194   Dali::FrameBuffer *arg1 = 0 ;
24195   Dali::FrameBuffer *result = 0 ;
24196
24197   arg1 = (Dali::FrameBuffer *)jarg1;
24198   if (!arg1) {
24199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24200     return 0;
24201   }
24202   {
24203     try {
24204       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24205     } catch (std::out_of_range& e) {
24206       {
24207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24208       };
24209     } catch (std::exception& e) {
24210       {
24211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24212       };
24213     } catch (...) {
24214       {
24215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24216       };
24217     }
24218   }
24219   jresult = (void *)result;
24220   return jresult;
24221 }
24222
24223
24224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24225   void * jresult ;
24226   Dali::BaseHandle arg1 ;
24227   Dali::BaseHandle *argp1 ;
24228   Dali::FrameBuffer result;
24229
24230   argp1 = (Dali::BaseHandle *)jarg1;
24231   if (!argp1) {
24232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24233     return 0;
24234   }
24235   arg1 = *argp1;
24236   {
24237     try {
24238       result = Dali::FrameBuffer::DownCast(arg1);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24250       };
24251     }
24252   }
24253   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24259   void * jresult ;
24260   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24261   Dali::FrameBuffer *arg2 = 0 ;
24262   Dali::FrameBuffer *result = 0 ;
24263
24264   arg1 = (Dali::FrameBuffer *)jarg1;
24265   arg2 = (Dali::FrameBuffer *)jarg2;
24266   if (!arg2) {
24267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24268     return 0;
24269   }
24270   {
24271     try {
24272       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24273     } catch (std::out_of_range& e) {
24274       {
24275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (std::exception& e) {
24278       {
24279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (...) {
24282       {
24283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24284       };
24285     }
24286   }
24287   jresult = (void *)result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24293   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24294   Dali::Texture *arg2 = 0 ;
24295
24296   arg1 = (Dali::FrameBuffer *)jarg1;
24297   arg2 = (Dali::Texture *)jarg2;
24298   if (!arg2) {
24299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24300     return ;
24301   }
24302   {
24303     try {
24304       (arg1)->AttachColorTexture(*arg2);
24305     } catch (std::out_of_range& e) {
24306       {
24307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24308       };
24309     } catch (std::exception& e) {
24310       {
24311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24312       };
24313     } catch (...) {
24314       {
24315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24316       };
24317     }
24318   }
24319 }
24320
24321
24322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24323   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24324   Dali::Texture *arg2 = 0 ;
24325   unsigned int arg3 ;
24326   unsigned int arg4 ;
24327
24328   arg1 = (Dali::FrameBuffer *)jarg1;
24329   arg2 = (Dali::Texture *)jarg2;
24330   if (!arg2) {
24331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24332     return ;
24333   }
24334   arg3 = (unsigned int)jarg3;
24335   arg4 = (unsigned int)jarg4;
24336   {
24337     try {
24338       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24339     } catch (std::out_of_range& e) {
24340       {
24341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24342       };
24343     } catch (std::exception& e) {
24344       {
24345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24346       };
24347     } catch (...) {
24348       {
24349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24350       };
24351     }
24352   }
24353 }
24354
24355
24356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24357   void * jresult ;
24358   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24359   Dali::Texture result;
24360
24361   arg1 = (Dali::FrameBuffer *)jarg1;
24362   {
24363     try {
24364       result = (arg1)->GetColorTexture();
24365     } catch (std::out_of_range& e) {
24366       {
24367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24368       };
24369     } catch (std::exception& e) {
24370       {
24371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24372       };
24373     } catch (...) {
24374       {
24375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24376       };
24377     }
24378   }
24379   jresult = new Dali::Texture((const Dali::Texture &)result);
24380   return jresult;
24381 }
24382
24383
24384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24385   void * jresult ;
24386   Dali::RenderTaskList *result = 0 ;
24387
24388   {
24389     try {
24390       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24391     } catch (std::out_of_range& e) {
24392       {
24393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (std::exception& e) {
24396       {
24397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405   jresult = (void *)result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24411   void * jresult ;
24412   Dali::BaseHandle arg1 ;
24413   Dali::BaseHandle *argp1 ;
24414   Dali::RenderTaskList result;
24415
24416   argp1 = (Dali::BaseHandle *)jarg1;
24417   if (!argp1) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24419     return 0;
24420   }
24421   arg1 = *argp1;
24422   {
24423     try {
24424       result = Dali::RenderTaskList::DownCast(arg1);
24425     } catch (std::out_of_range& e) {
24426       {
24427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24428       };
24429     } catch (std::exception& e) {
24430       {
24431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24432       };
24433     } catch (...) {
24434       {
24435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24436       };
24437     }
24438   }
24439   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24440   return jresult;
24441 }
24442
24443
24444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24445   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24446
24447   arg1 = (Dali::RenderTaskList *)jarg1;
24448   {
24449     try {
24450       delete arg1;
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24458       };
24459     } catch (...) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24462       };
24463     }
24464   }
24465 }
24466
24467
24468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24469   void * jresult ;
24470   Dali::RenderTaskList *arg1 = 0 ;
24471   Dali::RenderTaskList *result = 0 ;
24472
24473   arg1 = (Dali::RenderTaskList *)jarg1;
24474   if (!arg1) {
24475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24476     return 0;
24477   }
24478   {
24479     try {
24480       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24481     } catch (std::out_of_range& e) {
24482       {
24483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (std::exception& e) {
24486       {
24487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (...) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24492       };
24493     }
24494   }
24495   jresult = (void *)result;
24496   return jresult;
24497 }
24498
24499
24500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24501   void * jresult ;
24502   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24503   Dali::RenderTaskList *arg2 = 0 ;
24504   Dali::RenderTaskList *result = 0 ;
24505
24506   arg1 = (Dali::RenderTaskList *)jarg1;
24507   arg2 = (Dali::RenderTaskList *)jarg2;
24508   if (!arg2) {
24509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24510     return 0;
24511   }
24512   {
24513     try {
24514       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24515     } catch (std::out_of_range& e) {
24516       {
24517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24518       };
24519     } catch (std::exception& e) {
24520       {
24521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (...) {
24524       {
24525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24526       };
24527     }
24528   }
24529   jresult = (void *)result;
24530   return jresult;
24531 }
24532
24533
24534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24535   void * jresult ;
24536   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24537   Dali::RenderTask result;
24538
24539   arg1 = (Dali::RenderTaskList *)jarg1;
24540   {
24541     try {
24542       result = (arg1)->CreateTask();
24543     } catch (std::out_of_range& e) {
24544       {
24545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (std::exception& e) {
24548       {
24549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24550       };
24551     } catch (...) {
24552       {
24553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24554       };
24555     }
24556   }
24557   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24558   return jresult;
24559 }
24560
24561
24562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24563   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24564   Dali::RenderTask arg2 ;
24565   Dali::RenderTask *argp2 ;
24566
24567   arg1 = (Dali::RenderTaskList *)jarg1;
24568   argp2 = (Dali::RenderTask *)jarg2;
24569   if (!argp2) {
24570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24571     return ;
24572   }
24573   arg2 = *argp2;
24574   {
24575     try {
24576       (arg1)->RemoveTask(arg2);
24577     } catch (std::out_of_range& e) {
24578       {
24579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24580       };
24581     } catch (std::exception& e) {
24582       {
24583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24588       };
24589     }
24590   }
24591 }
24592
24593
24594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24595   unsigned int jresult ;
24596   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24597   unsigned int result;
24598
24599   arg1 = (Dali::RenderTaskList *)jarg1;
24600   {
24601     try {
24602       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24603     } catch (std::out_of_range& e) {
24604       {
24605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (std::exception& e) {
24608       {
24609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24610       };
24611     } catch (...) {
24612       {
24613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24614       };
24615     }
24616   }
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621
24622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24623   void * jresult ;
24624   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24625   unsigned int arg2 ;
24626   Dali::RenderTask result;
24627
24628   arg1 = (Dali::RenderTaskList *)jarg1;
24629   arg2 = (unsigned int)jarg2;
24630   {
24631     try {
24632       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24633     } catch (std::out_of_range& e) {
24634       {
24635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (std::exception& e) {
24638       {
24639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24640       };
24641     } catch (...) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24644       };
24645     }
24646   }
24647   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24653   int jresult ;
24654   int result;
24655
24656   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24657   jresult = (int)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24663   int jresult ;
24664   int result;
24665
24666   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24667   jresult = (int)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24673   int jresult ;
24674   int result;
24675
24676   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24677   jresult = (int)result;
24678   return jresult;
24679 }
24680
24681
24682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24683   int jresult ;
24684   int result;
24685
24686   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24687   jresult = (int)result;
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24693   void * jresult ;
24694   Dali::RenderTask::Property *result = 0 ;
24695
24696   {
24697     try {
24698       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24699     } catch (std::out_of_range& e) {
24700       {
24701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24702       };
24703     } catch (std::exception& e) {
24704       {
24705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24706       };
24707     } catch (...) {
24708       {
24709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24710       };
24711     }
24712   }
24713   jresult = (void *)result;
24714   return jresult;
24715 }
24716
24717
24718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24719   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24720
24721   arg1 = (Dali::RenderTask::Property *)jarg1;
24722   {
24723     try {
24724       delete arg1;
24725     } catch (std::out_of_range& e) {
24726       {
24727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24728       };
24729     } catch (std::exception& e) {
24730       {
24731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24736       };
24737     }
24738   }
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24743   void * jresult ;
24744   bool (*result)(Dali::Vector2 &) = 0 ;
24745
24746   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24747   jresult = (void *)result;
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24753   void * jresult ;
24754   bool (*result)(Dali::Vector2 &) = 0 ;
24755
24756   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24757   jresult = (void *)result;
24758   return jresult;
24759 }
24760
24761
24762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24763   unsigned int jresult ;
24764   bool result;
24765
24766   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24767   jresult = result;
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24773   unsigned int jresult ;
24774   bool result;
24775
24776   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24783   void * jresult ;
24784   Dali::Vector4 *result = 0 ;
24785
24786   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24787   jresult = (void *)result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24793   unsigned int jresult ;
24794   bool result;
24795
24796   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24797   jresult = result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24803   unsigned int jresult ;
24804   bool result;
24805
24806   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24807   jresult = result;
24808   return jresult;
24809 }
24810
24811
24812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24813   unsigned int jresult ;
24814   unsigned int result;
24815
24816   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24817   jresult = result;
24818   return jresult;
24819 }
24820
24821
24822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24823   void * jresult ;
24824   Dali::RenderTask *result = 0 ;
24825
24826   {
24827     try {
24828       result = (Dali::RenderTask *)new Dali::RenderTask();
24829     } catch (std::out_of_range& e) {
24830       {
24831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24832       };
24833     } catch (std::exception& e) {
24834       {
24835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24836       };
24837     } catch (...) {
24838       {
24839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24840       };
24841     }
24842   }
24843   jresult = (void *)result;
24844   return jresult;
24845 }
24846
24847
24848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24849   void * jresult ;
24850   Dali::BaseHandle arg1 ;
24851   Dali::BaseHandle *argp1 ;
24852   Dali::RenderTask result;
24853
24854   argp1 = (Dali::BaseHandle *)jarg1;
24855   if (!argp1) {
24856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24857     return 0;
24858   }
24859   arg1 = *argp1;
24860   {
24861     try {
24862       result = Dali::RenderTask::DownCast(arg1);
24863     } catch (std::out_of_range& e) {
24864       {
24865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24866       };
24867     } catch (std::exception& e) {
24868       {
24869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24870       };
24871     } catch (...) {
24872       {
24873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24874       };
24875     }
24876   }
24877   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24878   return jresult;
24879 }
24880
24881
24882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24883   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24884
24885   arg1 = (Dali::RenderTask *)jarg1;
24886   {
24887     try {
24888       delete arg1;
24889     } catch (std::out_of_range& e) {
24890       {
24891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24892       };
24893     } catch (std::exception& e) {
24894       {
24895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24900       };
24901     }
24902   }
24903 }
24904
24905
24906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24907   void * jresult ;
24908   Dali::RenderTask *arg1 = 0 ;
24909   Dali::RenderTask *result = 0 ;
24910
24911   arg1 = (Dali::RenderTask *)jarg1;
24912   if (!arg1) {
24913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24914     return 0;
24915   }
24916   {
24917     try {
24918       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (...) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24930       };
24931     }
24932   }
24933   jresult = (void *)result;
24934   return jresult;
24935 }
24936
24937
24938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24939   void * jresult ;
24940   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24941   Dali::RenderTask *arg2 = 0 ;
24942   Dali::RenderTask *result = 0 ;
24943
24944   arg1 = (Dali::RenderTask *)jarg1;
24945   arg2 = (Dali::RenderTask *)jarg2;
24946   if (!arg2) {
24947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24948     return 0;
24949   }
24950   {
24951     try {
24952       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24953     } catch (std::out_of_range& e) {
24954       {
24955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24956       };
24957     } catch (std::exception& e) {
24958       {
24959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24960       };
24961     } catch (...) {
24962       {
24963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24964       };
24965     }
24966   }
24967   jresult = (void *)result;
24968   return jresult;
24969 }
24970
24971
24972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24973   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24974   Dali::Actor arg2 ;
24975   Dali::Actor *argp2 ;
24976
24977   arg1 = (Dali::RenderTask *)jarg1;
24978   argp2 = (Dali::Actor *)jarg2;
24979   if (!argp2) {
24980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24981     return ;
24982   }
24983   arg2 = *argp2;
24984   {
24985     try {
24986       (arg1)->SetSourceActor(arg2);
24987     } catch (std::out_of_range& e) {
24988       {
24989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24990       };
24991     } catch (std::exception& e) {
24992       {
24993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24998       };
24999     }
25000   }
25001 }
25002
25003
25004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25005   void * jresult ;
25006   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25007   Dali::Actor result;
25008
25009   arg1 = (Dali::RenderTask *)jarg1;
25010   {
25011     try {
25012       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25013     } catch (std::out_of_range& e) {
25014       {
25015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25016       };
25017     } catch (std::exception& e) {
25018       {
25019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25020       };
25021     } catch (...) {
25022       {
25023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25024       };
25025     }
25026   }
25027   jresult = new Dali::Actor((const Dali::Actor &)result);
25028   return jresult;
25029 }
25030
25031
25032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25033   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25034   bool arg2 ;
25035
25036   arg1 = (Dali::RenderTask *)jarg1;
25037   arg2 = jarg2 ? true : false;
25038   {
25039     try {
25040       (arg1)->SetExclusive(arg2);
25041     } catch (std::out_of_range& e) {
25042       {
25043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25044       };
25045     } catch (std::exception& e) {
25046       {
25047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25048       };
25049     } catch (...) {
25050       {
25051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25052       };
25053     }
25054   }
25055 }
25056
25057
25058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25059   unsigned int jresult ;
25060   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25061   bool result;
25062
25063   arg1 = (Dali::RenderTask *)jarg1;
25064   {
25065     try {
25066       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25067     } catch (std::out_of_range& e) {
25068       {
25069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25070       };
25071     } catch (std::exception& e) {
25072       {
25073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25074       };
25075     } catch (...) {
25076       {
25077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25078       };
25079     }
25080   }
25081   jresult = result;
25082   return jresult;
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25087   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25088   bool arg2 ;
25089
25090   arg1 = (Dali::RenderTask *)jarg1;
25091   arg2 = jarg2 ? true : false;
25092   {
25093     try {
25094       (arg1)->SetInputEnabled(arg2);
25095     } catch (std::out_of_range& e) {
25096       {
25097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25098       };
25099     } catch (std::exception& e) {
25100       {
25101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25102       };
25103     } catch (...) {
25104       {
25105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25106       };
25107     }
25108   }
25109 }
25110
25111
25112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25113   unsigned int jresult ;
25114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25115   bool result;
25116
25117   arg1 = (Dali::RenderTask *)jarg1;
25118   {
25119     try {
25120       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25132       };
25133     }
25134   }
25135   jresult = result;
25136   return jresult;
25137 }
25138
25139
25140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25141   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25142   Dali::CameraActor arg2 ;
25143   Dali::CameraActor *argp2 ;
25144
25145   arg1 = (Dali::RenderTask *)jarg1;
25146   argp2 = (Dali::CameraActor *)jarg2;
25147   if (!argp2) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25149     return ;
25150   }
25151   arg2 = *argp2;
25152   {
25153     try {
25154       (arg1)->SetCameraActor(arg2);
25155     } catch (std::out_of_range& e) {
25156       {
25157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25158       };
25159     } catch (std::exception& e) {
25160       {
25161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25166       };
25167     }
25168   }
25169 }
25170
25171
25172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25173   void * jresult ;
25174   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25175   Dali::CameraActor result;
25176
25177   arg1 = (Dali::RenderTask *)jarg1;
25178   {
25179     try {
25180       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25181     } catch (std::out_of_range& e) {
25182       {
25183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25184       };
25185     } catch (std::exception& e) {
25186       {
25187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25188       };
25189     } catch (...) {
25190       {
25191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25192       };
25193     }
25194   }
25195   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25196   return jresult;
25197 }
25198
25199
25200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25201   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25202   Dali::FrameBufferImage arg2 ;
25203   Dali::FrameBufferImage *argp2 ;
25204
25205   arg1 = (Dali::RenderTask *)jarg1;
25206   argp2 = (Dali::FrameBufferImage *)jarg2;
25207   if (!argp2) {
25208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25209     return ;
25210   }
25211   arg2 = *argp2;
25212   {
25213     try {
25214       (arg1)->SetTargetFrameBuffer(arg2);
25215     } catch (std::out_of_range& e) {
25216       {
25217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25218       };
25219     } catch (std::exception& e) {
25220       {
25221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25222       };
25223     } catch (...) {
25224       {
25225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25226       };
25227     }
25228   }
25229 }
25230
25231
25232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25233   void * jresult ;
25234   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25235   Dali::FrameBufferImage result;
25236
25237   arg1 = (Dali::RenderTask *)jarg1;
25238   {
25239     try {
25240       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25241     } catch (std::out_of_range& e) {
25242       {
25243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25244       };
25245     } catch (std::exception& e) {
25246       {
25247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25248       };
25249     } catch (...) {
25250       {
25251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25252       };
25253     }
25254   }
25255   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25256   return jresult;
25257 }
25258
25259
25260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25261   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25262   Dali::FrameBuffer arg2 ;
25263   Dali::FrameBuffer *argp2 ;
25264
25265   arg1 = (Dali::RenderTask *)jarg1;
25266   argp2 = (Dali::FrameBuffer *)jarg2;
25267   if (!argp2) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25269     return ;
25270   }
25271   arg2 = *argp2;
25272   {
25273     try {
25274       (arg1)->SetFrameBuffer(arg2);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25293   void * jresult ;
25294   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25295   Dali::FrameBuffer result;
25296
25297   arg1 = (Dali::RenderTask *)jarg1;
25298   {
25299     try {
25300       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (...) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25312       };
25313     }
25314   }
25315   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25316   return jresult;
25317 }
25318
25319
25320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25321   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25322   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25323
25324   arg1 = (Dali::RenderTask *)jarg1;
25325   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25326   {
25327     try {
25328       (arg1)->SetScreenToFrameBufferFunction(arg2);
25329     } catch (std::out_of_range& e) {
25330       {
25331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25332       };
25333     } catch (std::exception& e) {
25334       {
25335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25336       };
25337     } catch (...) {
25338       {
25339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25340       };
25341     }
25342   }
25343 }
25344
25345
25346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25347   void * jresult ;
25348   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25349   Dali::RenderTask::ScreenToFrameBufferFunction result;
25350
25351   arg1 = (Dali::RenderTask *)jarg1;
25352   {
25353     try {
25354       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25355     } catch (std::out_of_range& e) {
25356       {
25357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25358       };
25359     } catch (std::exception& e) {
25360       {
25361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25362       };
25363     } catch (...) {
25364       {
25365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25366       };
25367     }
25368   }
25369   jresult = (void *)result;
25370   return jresult;
25371 }
25372
25373
25374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25376   Dali::Actor arg2 ;
25377   Dali::Actor *argp2 ;
25378
25379   arg1 = (Dali::RenderTask *)jarg1;
25380   argp2 = (Dali::Actor *)jarg2;
25381   if (!argp2) {
25382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25383     return ;
25384   }
25385   arg2 = *argp2;
25386   {
25387     try {
25388       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25389     } catch (std::out_of_range& e) {
25390       {
25391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25392       };
25393     } catch (std::exception& e) {
25394       {
25395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25396       };
25397     } catch (...) {
25398       {
25399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25400       };
25401     }
25402   }
25403 }
25404
25405
25406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25407   void * jresult ;
25408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25409   Dali::Actor result;
25410
25411   arg1 = (Dali::RenderTask *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429   jresult = new Dali::Actor((const Dali::Actor &)result);
25430   return jresult;
25431 }
25432
25433
25434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25436   Dali::Vector2 arg2 ;
25437   Dali::Vector2 *argp2 ;
25438
25439   arg1 = (Dali::RenderTask *)jarg1;
25440   argp2 = (Dali::Vector2 *)jarg2;
25441   if (!argp2) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25443     return ;
25444   }
25445   arg2 = *argp2;
25446   {
25447     try {
25448       (arg1)->SetViewportPosition(arg2);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25456       };
25457     } catch (...) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25460       };
25461     }
25462   }
25463 }
25464
25465
25466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25467   void * jresult ;
25468   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25469   Dali::Vector2 result;
25470
25471   arg1 = (Dali::RenderTask *)jarg1;
25472   {
25473     try {
25474       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25475     } catch (std::out_of_range& e) {
25476       {
25477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (std::exception& e) {
25480       {
25481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25495   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25496   Dali::Vector2 arg2 ;
25497   Dali::Vector2 *argp2 ;
25498
25499   arg1 = (Dali::RenderTask *)jarg1;
25500   argp2 = (Dali::Vector2 *)jarg2;
25501   if (!argp2) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25503     return ;
25504   }
25505   arg2 = *argp2;
25506   {
25507     try {
25508       (arg1)->SetViewportSize(arg2);
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (...) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25520       };
25521     }
25522   }
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25527   void * jresult ;
25528   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25529   Dali::Vector2 result;
25530
25531   arg1 = (Dali::RenderTask *)jarg1;
25532   {
25533     try {
25534       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (...) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25546       };
25547     }
25548   }
25549   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25550   return jresult;
25551 }
25552
25553
25554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25555   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25556   Dali::Viewport arg2 ;
25557   Dali::Viewport *argp2 ;
25558
25559   arg1 = (Dali::RenderTask *)jarg1;
25560   argp2 = (Dali::Viewport *)jarg2;
25561   if (!argp2) {
25562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25563     return ;
25564   }
25565   arg2 = *argp2;
25566   {
25567     try {
25568       (arg1)->SetViewport(arg2);
25569     } catch (std::out_of_range& e) {
25570       {
25571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25572       };
25573     } catch (std::exception& e) {
25574       {
25575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25580       };
25581     }
25582   }
25583 }
25584
25585
25586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25587   void * jresult ;
25588   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25589   Dali::Viewport result;
25590
25591   arg1 = (Dali::RenderTask *)jarg1;
25592   {
25593     try {
25594       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25595     } catch (std::out_of_range& e) {
25596       {
25597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25598       };
25599     } catch (std::exception& e) {
25600       {
25601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25602       };
25603     } catch (...) {
25604       {
25605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25606       };
25607     }
25608   }
25609   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25610   return jresult;
25611 }
25612
25613
25614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25615   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25616   Dali::Vector4 *arg2 = 0 ;
25617
25618   arg1 = (Dali::RenderTask *)jarg1;
25619   arg2 = (Dali::Vector4 *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25622     return ;
25623   }
25624   {
25625     try {
25626       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25638       };
25639     }
25640   }
25641 }
25642
25643
25644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25645   void * jresult ;
25646   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25647   Dali::Vector4 result;
25648
25649   arg1 = (Dali::RenderTask *)jarg1;
25650   {
25651     try {
25652       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25653     } catch (std::out_of_range& e) {
25654       {
25655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25656       };
25657     } catch (std::exception& e) {
25658       {
25659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25660       };
25661     } catch (...) {
25662       {
25663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25664       };
25665     }
25666   }
25667   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25668   return jresult;
25669 }
25670
25671
25672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25674   bool arg2 ;
25675
25676   arg1 = (Dali::RenderTask *)jarg1;
25677   arg2 = jarg2 ? true : false;
25678   {
25679     try {
25680       (arg1)->SetClearEnabled(arg2);
25681     } catch (std::out_of_range& e) {
25682       {
25683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25684       };
25685     } catch (std::exception& e) {
25686       {
25687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25692       };
25693     }
25694   }
25695 }
25696
25697
25698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25699   unsigned int jresult ;
25700   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25701   bool result;
25702
25703   arg1 = (Dali::RenderTask *)jarg1;
25704   {
25705     try {
25706       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25714       };
25715     } catch (...) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25718       };
25719     }
25720   }
25721   jresult = result;
25722   return jresult;
25723 }
25724
25725
25726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25727   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25728   bool arg2 ;
25729
25730   arg1 = (Dali::RenderTask *)jarg1;
25731   arg2 = jarg2 ? true : false;
25732   {
25733     try {
25734       (arg1)->SetCullMode(arg2);
25735     } catch (std::out_of_range& e) {
25736       {
25737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25738       };
25739     } catch (std::exception& e) {
25740       {
25741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25746       };
25747     }
25748   }
25749 }
25750
25751
25752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25753   unsigned int jresult ;
25754   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25755   bool result;
25756
25757   arg1 = (Dali::RenderTask *)jarg1;
25758   {
25759     try {
25760       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25761     } catch (std::out_of_range& e) {
25762       {
25763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25764       };
25765     } catch (std::exception& e) {
25766       {
25767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25768       };
25769     } catch (...) {
25770       {
25771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25772       };
25773     }
25774   }
25775   jresult = result;
25776   return jresult;
25777 }
25778
25779
25780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25782   unsigned int arg2 ;
25783
25784   arg1 = (Dali::RenderTask *)jarg1;
25785   arg2 = (unsigned int)jarg2;
25786   {
25787     try {
25788       (arg1)->SetRefreshRate(arg2);
25789     } catch (std::out_of_range& e) {
25790       {
25791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25792       };
25793     } catch (std::exception& e) {
25794       {
25795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25796       };
25797     } catch (...) {
25798       {
25799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25800       };
25801     }
25802   }
25803 }
25804
25805
25806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25807   unsigned int jresult ;
25808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25809   unsigned int result;
25810
25811   arg1 = (Dali::RenderTask *)jarg1;
25812   {
25813     try {
25814       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829   jresult = result;
25830   return jresult;
25831 }
25832
25833
25834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25835   unsigned int jresult ;
25836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25837   Dali::Vector3 *arg2 = 0 ;
25838   float *arg3 = 0 ;
25839   float *arg4 = 0 ;
25840   bool result;
25841
25842   arg1 = (Dali::RenderTask *)jarg1;
25843   arg2 = (Dali::Vector3 *)jarg2;
25844   if (!arg2) {
25845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25846     return 0;
25847   }
25848   arg3 = (float *)jarg3;
25849   arg4 = (float *)jarg4;
25850   {
25851     try {
25852       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (...) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25864       };
25865     }
25866   }
25867   jresult = result;
25868   return jresult;
25869 }
25870
25871
25872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25873   unsigned int jresult ;
25874   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25875   Dali::Actor arg2 ;
25876   float arg3 ;
25877   float arg4 ;
25878   float *arg5 = 0 ;
25879   float *arg6 = 0 ;
25880   Dali::Actor *argp2 ;
25881   bool result;
25882
25883   arg1 = (Dali::RenderTask *)jarg1;
25884   argp2 = (Dali::Actor *)jarg2;
25885   if (!argp2) {
25886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25887     return 0;
25888   }
25889   arg2 = *argp2;
25890   arg3 = (float)jarg3;
25891   arg4 = (float)jarg4;
25892   arg5 = (float *)jarg5;
25893   arg6 = (float *)jarg6;
25894   {
25895     try {
25896       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911   jresult = result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25917   void * jresult ;
25918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25919   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25920
25921   arg1 = (Dali::RenderTask *)jarg1;
25922   {
25923     try {
25924       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25925     } catch (std::out_of_range& e) {
25926       {
25927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25928       };
25929     } catch (std::exception& e) {
25930       {
25931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25932       };
25933     } catch (...) {
25934       {
25935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25936       };
25937     }
25938   }
25939   jresult = (void *)result;
25940   return jresult;
25941 }
25942
25943
25944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25945   void * jresult ;
25946   int arg1 ;
25947   Dali::TouchPoint::State arg2 ;
25948   float arg3 ;
25949   float arg4 ;
25950   Dali::TouchPoint *result = 0 ;
25951
25952   arg1 = (int)jarg1;
25953   arg2 = (Dali::TouchPoint::State)jarg2;
25954   arg3 = (float)jarg3;
25955   arg4 = (float)jarg4;
25956   {
25957     try {
25958       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25959     } catch (std::out_of_range& e) {
25960       {
25961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (std::exception& e) {
25964       {
25965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973   jresult = (void *)result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25979   void * jresult ;
25980   int arg1 ;
25981   Dali::TouchPoint::State arg2 ;
25982   float arg3 ;
25983   float arg4 ;
25984   float arg5 ;
25985   float arg6 ;
25986   Dali::TouchPoint *result = 0 ;
25987
25988   arg1 = (int)jarg1;
25989   arg2 = (Dali::TouchPoint::State)jarg2;
25990   arg3 = (float)jarg3;
25991   arg4 = (float)jarg4;
25992   arg5 = (float)jarg5;
25993   arg6 = (float)jarg6;
25994   {
25995     try {
25996       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26004       };
26005     } catch (...) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26008       };
26009     }
26010   }
26011   jresult = (void *)result;
26012   return jresult;
26013 }
26014
26015
26016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018
26019   arg1 = (Dali::TouchPoint *)jarg1;
26020   {
26021     try {
26022       delete arg1;
26023     } catch (std::out_of_range& e) {
26024       {
26025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26026       };
26027     } catch (std::exception& e) {
26028       {
26029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26030       };
26031     } catch (...) {
26032       {
26033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26034       };
26035     }
26036   }
26037 }
26038
26039
26040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26041   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26042   int arg2 ;
26043
26044   arg1 = (Dali::TouchPoint *)jarg1;
26045   arg2 = (int)jarg2;
26046   if (arg1) (arg1)->deviceId = arg2;
26047 }
26048
26049
26050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26051   int jresult ;
26052   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26053   int result;
26054
26055   arg1 = (Dali::TouchPoint *)jarg1;
26056   result = (int) ((arg1)->deviceId);
26057   jresult = result;
26058   return jresult;
26059 }
26060
26061
26062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26063   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26064   Dali::TouchPoint::State arg2 ;
26065
26066   arg1 = (Dali::TouchPoint *)jarg1;
26067   arg2 = (Dali::TouchPoint::State)jarg2;
26068   if (arg1) (arg1)->state = arg2;
26069 }
26070
26071
26072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26073   int jresult ;
26074   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26075   Dali::TouchPoint::State result;
26076
26077   arg1 = (Dali::TouchPoint *)jarg1;
26078   result = (Dali::TouchPoint::State) ((arg1)->state);
26079   jresult = (int)result;
26080   return jresult;
26081 }
26082
26083
26084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26085   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26086   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26087
26088   arg1 = (Dali::TouchPoint *)jarg1;
26089   arg2 = (Dali::Actor *)jarg2;
26090   if (arg1) (arg1)->hitActor = *arg2;
26091 }
26092
26093
26094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26095   void * jresult ;
26096   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26097   Dali::Actor *result = 0 ;
26098
26099   arg1 = (Dali::TouchPoint *)jarg1;
26100   result = (Dali::Actor *)& ((arg1)->hitActor);
26101   jresult = (void *)result;
26102   return jresult;
26103 }
26104
26105
26106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26107   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26108   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26109
26110   arg1 = (Dali::TouchPoint *)jarg1;
26111   arg2 = (Dali::Vector2 *)jarg2;
26112   if (arg1) (arg1)->local = *arg2;
26113 }
26114
26115
26116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26117   void * jresult ;
26118   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26119   Dali::Vector2 *result = 0 ;
26120
26121   arg1 = (Dali::TouchPoint *)jarg1;
26122   result = (Dali::Vector2 *)& ((arg1)->local);
26123   jresult = (void *)result;
26124   return jresult;
26125 }
26126
26127
26128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26129   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26130   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26131
26132   arg1 = (Dali::TouchPoint *)jarg1;
26133   arg2 = (Dali::Vector2 *)jarg2;
26134   if (arg1) (arg1)->screen = *arg2;
26135 }
26136
26137
26138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26139   void * jresult ;
26140   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26141   Dali::Vector2 *result = 0 ;
26142
26143   arg1 = (Dali::TouchPoint *)jarg1;
26144   result = (Dali::Vector2 *)& ((arg1)->screen);
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26151   void * jresult ;
26152   Dali::TouchData *result = 0 ;
26153
26154   {
26155     try {
26156       result = (Dali::TouchData *)new Dali::TouchData();
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26164       };
26165     } catch (...) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26168       };
26169     }
26170   }
26171   jresult = (void *)result;
26172   return jresult;
26173 }
26174
26175
26176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26177   void * jresult ;
26178   Dali::TouchData *arg1 = 0 ;
26179   Dali::TouchData *result = 0 ;
26180
26181   arg1 = (Dali::TouchData *)jarg1;
26182   if (!arg1) {
26183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26184     return 0;
26185   }
26186   {
26187     try {
26188       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26189     } catch (std::out_of_range& e) {
26190       {
26191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26192       };
26193     } catch (std::exception& e) {
26194       {
26195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26196       };
26197     } catch (...) {
26198       {
26199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26200       };
26201     }
26202   }
26203   jresult = (void *)result;
26204   return jresult;
26205 }
26206
26207
26208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26209   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26210
26211   arg1 = (Dali::TouchData *)jarg1;
26212   {
26213     try {
26214       delete arg1;
26215     } catch (std::out_of_range& e) {
26216       {
26217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26218       };
26219     } catch (std::exception& e) {
26220       {
26221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26222       };
26223     } catch (...) {
26224       {
26225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26226       };
26227     }
26228   }
26229 }
26230
26231
26232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26233   void * jresult ;
26234   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26235   Dali::TouchData *arg2 = 0 ;
26236   Dali::TouchData *result = 0 ;
26237
26238   arg1 = (Dali::TouchData *)jarg1;
26239   arg2 = (Dali::TouchData *)jarg2;
26240   if (!arg2) {
26241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26242     return 0;
26243   }
26244   {
26245     try {
26246       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26247     } catch (std::out_of_range& e) {
26248       {
26249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26250       };
26251     } catch (std::exception& e) {
26252       {
26253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (...) {
26256       {
26257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26258       };
26259     }
26260   }
26261   jresult = (void *)result;
26262   return jresult;
26263 }
26264
26265
26266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26267   unsigned long jresult ;
26268   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26269   unsigned long result;
26270
26271   arg1 = (Dali::TouchData *)jarg1;
26272   {
26273     try {
26274       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289   jresult = (unsigned long)result;
26290   return jresult;
26291 }
26292
26293
26294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26295   unsigned long jresult ;
26296   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26297   std::size_t result;
26298
26299   arg1 = (Dali::TouchData *)jarg1;
26300   {
26301     try {
26302       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26303     } catch (std::out_of_range& e) {
26304       {
26305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26306       };
26307     } catch (std::exception& e) {
26308       {
26309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26310       };
26311     } catch (...) {
26312       {
26313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26314       };
26315     }
26316   }
26317   jresult = (unsigned long)result;
26318   return jresult;
26319 }
26320
26321
26322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26323   int jresult ;
26324   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26325   std::size_t arg2 ;
26326   int32_t result;
26327
26328   arg1 = (Dali::TouchData *)jarg1;
26329   arg2 = (std::size_t)jarg2;
26330   {
26331     try {
26332       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26333     } catch (std::out_of_range& e) {
26334       {
26335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (std::exception& e) {
26338       {
26339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347   jresult = result;
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26353   int jresult ;
26354   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26355   std::size_t arg2 ;
26356   Dali::PointState::Type result;
26357
26358   arg1 = (Dali::TouchData *)jarg1;
26359   arg2 = (std::size_t)jarg2;
26360   {
26361     try {
26362       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377   jresult = (int)result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26383   void * jresult ;
26384   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26385   std::size_t arg2 ;
26386   Dali::Actor result;
26387
26388   arg1 = (Dali::TouchData *)jarg1;
26389   arg2 = (std::size_t)jarg2;
26390   {
26391     try {
26392       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26400       };
26401     } catch (...) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26404       };
26405     }
26406   }
26407   jresult = new Dali::Actor((const Dali::Actor &)result);
26408   return jresult;
26409 }
26410
26411
26412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26413   void * jresult ;
26414   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26415   std::size_t arg2 ;
26416   Dali::Vector2 *result = 0 ;
26417
26418   arg1 = (Dali::TouchData *)jarg1;
26419   arg2 = (std::size_t)jarg2;
26420   {
26421     try {
26422       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26423     } catch (std::out_of_range& e) {
26424       {
26425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26426       };
26427     } catch (std::exception& e) {
26428       {
26429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26430       };
26431     } catch (...) {
26432       {
26433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26434       };
26435     }
26436   }
26437   jresult = (void *)result;
26438   return jresult;
26439 }
26440
26441
26442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26443   void * jresult ;
26444   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26445   std::size_t arg2 ;
26446   Dali::Vector2 *result = 0 ;
26447
26448   arg1 = (Dali::TouchData *)jarg1;
26449   arg2 = (std::size_t)jarg2;
26450   {
26451     try {
26452       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26453     } catch (std::out_of_range& e) {
26454       {
26455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26456       };
26457     } catch (std::exception& e) {
26458       {
26459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26460       };
26461     } catch (...) {
26462       {
26463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26464       };
26465     }
26466   }
26467   jresult = (void *)result;
26468   return jresult;
26469 }
26470
26471
26472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26473   float jresult ;
26474   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26475   std::size_t arg2 ;
26476   float result;
26477
26478   arg1 = (Dali::TouchData *)jarg1;
26479   arg2 = (std::size_t)jarg2;
26480   {
26481     try {
26482       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26483     } catch (std::out_of_range& e) {
26484       {
26485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26486       };
26487     } catch (std::exception& e) {
26488       {
26489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26490       };
26491     } catch (...) {
26492       {
26493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26494       };
26495     }
26496   }
26497   jresult = result;
26498   return jresult;
26499 }
26500
26501
26502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26503   void * jresult ;
26504   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26505   std::size_t arg2 ;
26506   Dali::Vector2 *result = 0 ;
26507
26508   arg1 = (Dali::TouchData *)jarg1;
26509   arg2 = (std::size_t)jarg2;
26510   {
26511     try {
26512       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26513     } catch (std::out_of_range& e) {
26514       {
26515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26516       };
26517     } catch (std::exception& e) {
26518       {
26519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26520       };
26521     } catch (...) {
26522       {
26523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26524       };
26525     }
26526   }
26527   jresult = (void *)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26533   float jresult ;
26534   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26535   std::size_t arg2 ;
26536   float result;
26537
26538   arg1 = (Dali::TouchData *)jarg1;
26539   arg2 = (std::size_t)jarg2;
26540   {
26541     try {
26542       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26543     } catch (std::out_of_range& e) {
26544       {
26545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26546       };
26547     } catch (std::exception& e) {
26548       {
26549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26550       };
26551     } catch (...) {
26552       {
26553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26554       };
26555     }
26556   }
26557   jresult = result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26563   void * jresult ;
26564   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26565   std::size_t arg2 ;
26566   Dali::Degree result;
26567
26568   arg1 = (Dali::TouchData *)jarg1;
26569   arg2 = (std::size_t)jarg2;
26570   {
26571     try {
26572       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26573     } catch (std::out_of_range& e) {
26574       {
26575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26576       };
26577     } catch (std::exception& e) {
26578       {
26579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (...) {
26582       {
26583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26584       };
26585     }
26586   }
26587   jresult = new Dali::Degree((const Dali::Degree &)result);
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26593   void * jresult ;
26594   Dali::GestureDetector *result = 0 ;
26595
26596   {
26597     try {
26598       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26599     } catch (std::out_of_range& e) {
26600       {
26601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26602       };
26603     } catch (std::exception& e) {
26604       {
26605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26606       };
26607     } catch (...) {
26608       {
26609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26610       };
26611     }
26612   }
26613   jresult = (void *)result;
26614   return jresult;
26615 }
26616
26617
26618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26619   void * jresult ;
26620   Dali::BaseHandle arg1 ;
26621   Dali::BaseHandle *argp1 ;
26622   Dali::GestureDetector result;
26623
26624   argp1 = (Dali::BaseHandle *)jarg1;
26625   if (!argp1) {
26626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26627     return 0;
26628   }
26629   arg1 = *argp1;
26630   {
26631     try {
26632       result = Dali::GestureDetector::DownCast(arg1);
26633     } catch (std::out_of_range& e) {
26634       {
26635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26636       };
26637     } catch (std::exception& e) {
26638       {
26639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26640       };
26641     } catch (...) {
26642       {
26643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26644       };
26645     }
26646   }
26647   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26653   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26654
26655   arg1 = (Dali::GestureDetector *)jarg1;
26656   {
26657     try {
26658       delete arg1;
26659     } catch (std::out_of_range& e) {
26660       {
26661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26662       };
26663     } catch (std::exception& e) {
26664       {
26665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26666       };
26667     } catch (...) {
26668       {
26669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26670       };
26671     }
26672   }
26673 }
26674
26675
26676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26677   void * jresult ;
26678   Dali::GestureDetector *arg1 = 0 ;
26679   Dali::GestureDetector *result = 0 ;
26680
26681   arg1 = (Dali::GestureDetector *)jarg1;
26682   if (!arg1) {
26683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26684     return 0;
26685   }
26686   {
26687     try {
26688       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26700       };
26701     }
26702   }
26703   jresult = (void *)result;
26704   return jresult;
26705 }
26706
26707
26708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26709   void * jresult ;
26710   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26711   Dali::GestureDetector *arg2 = 0 ;
26712   Dali::GestureDetector *result = 0 ;
26713
26714   arg1 = (Dali::GestureDetector *)jarg1;
26715   arg2 = (Dali::GestureDetector *)jarg2;
26716   if (!arg2) {
26717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26718     return 0;
26719   }
26720   {
26721     try {
26722       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26723     } catch (std::out_of_range& e) {
26724       {
26725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26726       };
26727     } catch (std::exception& e) {
26728       {
26729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26730       };
26731     } catch (...) {
26732       {
26733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26734       };
26735     }
26736   }
26737   jresult = (void *)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26743   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26744   Dali::Actor arg2 ;
26745   Dali::Actor *argp2 ;
26746
26747   arg1 = (Dali::GestureDetector *)jarg1;
26748   argp2 = (Dali::Actor *)jarg2;
26749   if (!argp2) {
26750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26751     return ;
26752   }
26753   arg2 = *argp2;
26754   {
26755     try {
26756       (arg1)->Attach(arg2);
26757     } catch (std::out_of_range& e) {
26758       {
26759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26760       };
26761     } catch (std::exception& e) {
26762       {
26763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26764       };
26765     } catch (...) {
26766       {
26767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26768       };
26769     }
26770   }
26771 }
26772
26773
26774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26775   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26776   Dali::Actor arg2 ;
26777   Dali::Actor *argp2 ;
26778
26779   arg1 = (Dali::GestureDetector *)jarg1;
26780   argp2 = (Dali::Actor *)jarg2;
26781   if (!argp2) {
26782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26783     return ;
26784   }
26785   arg2 = *argp2;
26786   {
26787     try {
26788       (arg1)->Detach(arg2);
26789     } catch (std::out_of_range& e) {
26790       {
26791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26792       };
26793     } catch (std::exception& e) {
26794       {
26795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (...) {
26798       {
26799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26800       };
26801     }
26802   }
26803 }
26804
26805
26806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26807   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26808
26809   arg1 = (Dali::GestureDetector *)jarg1;
26810   {
26811     try {
26812       (arg1)->DetachAll();
26813     } catch (std::out_of_range& e) {
26814       {
26815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (std::exception& e) {
26818       {
26819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827 }
26828
26829
26830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26831   unsigned long jresult ;
26832   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26833   size_t result;
26834
26835   arg1 = (Dali::GestureDetector *)jarg1;
26836   {
26837     try {
26838       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26846       };
26847     } catch (...) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26850       };
26851     }
26852   }
26853   jresult = (unsigned long)result;
26854   return jresult;
26855 }
26856
26857
26858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26859   void * jresult ;
26860   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26861   size_t arg2 ;
26862   Dali::Actor result;
26863
26864   arg1 = (Dali::GestureDetector *)jarg1;
26865   arg2 = (size_t)jarg2;
26866   {
26867     try {
26868       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26869     } catch (std::out_of_range& e) {
26870       {
26871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26872       };
26873     } catch (std::exception& e) {
26874       {
26875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26876       };
26877     } catch (...) {
26878       {
26879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26880       };
26881     }
26882   }
26883   jresult = new Dali::Actor((const Dali::Actor &)result);
26884   return jresult;
26885 }
26886
26887
26888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26889   void * jresult ;
26890   Dali::Gesture *arg1 = 0 ;
26891   Dali::Gesture *result = 0 ;
26892
26893   arg1 = (Dali::Gesture *)jarg1;
26894   if (!arg1) {
26895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26896     return 0;
26897   }
26898   {
26899     try {
26900       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26901     } catch (std::out_of_range& e) {
26902       {
26903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (std::exception& e) {
26906       {
26907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26908       };
26909     } catch (...) {
26910       {
26911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26912       };
26913     }
26914   }
26915   jresult = (void *)result;
26916   return jresult;
26917 }
26918
26919
26920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26921   void * jresult ;
26922   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26923   Dali::Gesture *arg2 = 0 ;
26924   Dali::Gesture *result = 0 ;
26925
26926   arg1 = (Dali::Gesture *)jarg1;
26927   arg2 = (Dali::Gesture *)jarg2;
26928   if (!arg2) {
26929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26930     return 0;
26931   }
26932   {
26933     try {
26934       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26935     } catch (std::out_of_range& e) {
26936       {
26937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26938       };
26939     } catch (std::exception& e) {
26940       {
26941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26942       };
26943     } catch (...) {
26944       {
26945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26946       };
26947     }
26948   }
26949   jresult = (void *)result;
26950   return jresult;
26951 }
26952
26953
26954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26955   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26956
26957   arg1 = (Dali::Gesture *)jarg1;
26958   {
26959     try {
26960       delete arg1;
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (...) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26972       };
26973     }
26974   }
26975 }
26976
26977
26978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26979   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26980   Dali::Gesture::Type arg2 ;
26981
26982   arg1 = (Dali::Gesture *)jarg1;
26983   arg2 = (Dali::Gesture::Type)jarg2;
26984   if (arg1) (arg1)->type = arg2;
26985 }
26986
26987
26988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26989   int jresult ;
26990   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26991   Dali::Gesture::Type result;
26992
26993   arg1 = (Dali::Gesture *)jarg1;
26994   result = (Dali::Gesture::Type) ((arg1)->type);
26995   jresult = (int)result;
26996   return jresult;
26997 }
26998
26999
27000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
27001   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27002   Dali::Gesture::State arg2 ;
27003
27004   arg1 = (Dali::Gesture *)jarg1;
27005   arg2 = (Dali::Gesture::State)jarg2;
27006   if (arg1) (arg1)->state = arg2;
27007 }
27008
27009
27010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27011   int jresult ;
27012   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27013   Dali::Gesture::State result;
27014
27015   arg1 = (Dali::Gesture *)jarg1;
27016   result = (Dali::Gesture::State) ((arg1)->state);
27017   jresult = (int)result;
27018   return jresult;
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27023   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27024   unsigned int arg2 ;
27025
27026   arg1 = (Dali::Gesture *)jarg1;
27027   arg2 = (unsigned int)jarg2;
27028   if (arg1) (arg1)->time = arg2;
27029 }
27030
27031
27032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27033   unsigned int jresult ;
27034   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27035   unsigned int result;
27036
27037   arg1 = (Dali::Gesture *)jarg1;
27038   result = (unsigned int) ((arg1)->time);
27039   jresult = result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27045   void * jresult ;
27046   Dali::HoverEvent *result = 0 ;
27047
27048   {
27049     try {
27050       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27051     } catch (std::out_of_range& e) {
27052       {
27053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27054       };
27055     } catch (std::exception& e) {
27056       {
27057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27058       };
27059     } catch (...) {
27060       {
27061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27062       };
27063     }
27064   }
27065   jresult = (void *)result;
27066   return jresult;
27067 }
27068
27069
27070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27071   void * jresult ;
27072   unsigned long arg1 ;
27073   Dali::HoverEvent *result = 0 ;
27074
27075   arg1 = (unsigned long)jarg1;
27076   {
27077     try {
27078       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27079     } catch (std::out_of_range& e) {
27080       {
27081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (std::exception& e) {
27084       {
27085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27086       };
27087     } catch (...) {
27088       {
27089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27090       };
27091     }
27092   }
27093   jresult = (void *)result;
27094   return jresult;
27095 }
27096
27097
27098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27099   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27100
27101   arg1 = (Dali::HoverEvent *)jarg1;
27102   {
27103     try {
27104       delete arg1;
27105     } catch (std::out_of_range& e) {
27106       {
27107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27108       };
27109     } catch (std::exception& e) {
27110       {
27111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27112       };
27113     } catch (...) {
27114       {
27115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27116       };
27117     }
27118   }
27119 }
27120
27121
27122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27123   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27124   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27125
27126   arg1 = (Dali::HoverEvent *)jarg1;
27127   arg2 = (Dali::TouchPointContainer *)jarg2;
27128   if (arg1) (arg1)->points = *arg2;
27129 }
27130
27131
27132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27133   void * jresult ;
27134   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27135   Dali::TouchPointContainer *result = 0 ;
27136
27137   arg1 = (Dali::HoverEvent *)jarg1;
27138   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27139   jresult = (void *)result;
27140   return jresult;
27141 }
27142
27143
27144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27146   unsigned long arg2 ;
27147
27148   arg1 = (Dali::HoverEvent *)jarg1;
27149   arg2 = (unsigned long)jarg2;
27150   if (arg1) (arg1)->time = arg2;
27151 }
27152
27153
27154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27155   unsigned long jresult ;
27156   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27157   unsigned long result;
27158
27159   arg1 = (Dali::HoverEvent *)jarg1;
27160   result = (unsigned long) ((arg1)->time);
27161   jresult = (unsigned long)result;
27162   return jresult;
27163 }
27164
27165
27166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27167   unsigned int jresult ;
27168   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27169   unsigned int result;
27170
27171   arg1 = (Dali::HoverEvent *)jarg1;
27172   {
27173     try {
27174       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27175     } catch (std::out_of_range& e) {
27176       {
27177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27178       };
27179     } catch (std::exception& e) {
27180       {
27181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27182       };
27183     } catch (...) {
27184       {
27185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27186       };
27187     }
27188   }
27189   jresult = result;
27190   return jresult;
27191 }
27192
27193
27194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27195   void * jresult ;
27196   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27197   unsigned int arg2 ;
27198   Dali::TouchPoint *result = 0 ;
27199
27200   arg1 = (Dali::HoverEvent *)jarg1;
27201   arg2 = (unsigned int)jarg2;
27202   {
27203     try {
27204       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27205     } catch (std::out_of_range& e) {
27206       {
27207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27208       };
27209     } catch (std::exception& e) {
27210       {
27211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27212       };
27213     } catch (...) {
27214       {
27215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27216       };
27217     }
27218   }
27219   jresult = (void *)result;
27220   return jresult;
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27225   void * jresult ;
27226   Dali::KeyEvent *result = 0 ;
27227
27228   {
27229     try {
27230       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27242       };
27243     }
27244   }
27245   jresult = (void *)result;
27246   return jresult;
27247 }
27248
27249
27250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27251   void * jresult ;
27252   std::string *arg1 = 0 ;
27253   std::string *arg2 = 0 ;
27254   int arg3 ;
27255   int arg4 ;
27256   unsigned long arg5 ;
27257   Dali::KeyEvent::State *arg6 = 0 ;
27258   Dali::KeyEvent::State temp6 ;
27259   Dali::KeyEvent *result = 0 ;
27260
27261   if (!jarg1) {
27262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27263     return 0;
27264   }
27265   std::string arg1_str(jarg1);
27266   arg1 = &arg1_str;
27267   if (!jarg2) {
27268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27269     return 0;
27270   }
27271   std::string arg2_str(jarg2);
27272   arg2 = &arg2_str;
27273   arg3 = (int)jarg3;
27274   arg4 = (int)jarg4;
27275   arg5 = (unsigned long)jarg5;
27276   temp6 = (Dali::KeyEvent::State)jarg6;
27277   arg6 = &temp6;
27278   {
27279     try {
27280       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27281     } catch (std::out_of_range& e) {
27282       {
27283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27284       };
27285     } catch (std::exception& e) {
27286       {
27287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27288       };
27289     } catch (...) {
27290       {
27291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27292       };
27293     }
27294   }
27295   jresult = (void *)result;
27296
27297   //argout typemap for const std::string&
27298
27299
27300   //argout typemap for const std::string&
27301
27302   return jresult;
27303 }
27304
27305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27306   void * jresult ;
27307   Dali::KeyEvent *arg1 = 0 ;
27308   Dali::KeyEvent *result = 0 ;
27309
27310   arg1 = (Dali::KeyEvent *)jarg1;
27311   if (!arg1) {
27312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27313     return 0;
27314   }
27315   {
27316     try {
27317       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27318     } catch (std::out_of_range& e) {
27319       {
27320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (std::exception& e) {
27323       {
27324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332   jresult = (void *)result;
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27338   void * jresult ;
27339   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27340   Dali::KeyEvent *arg2 = 0 ;
27341   Dali::KeyEvent *result = 0 ;
27342
27343   arg1 = (Dali::KeyEvent *)jarg1;
27344   arg2 = (Dali::KeyEvent *)jarg2;
27345   if (!arg2) {
27346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27347     return 0;
27348   }
27349   {
27350     try {
27351       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27352     } catch (std::out_of_range& e) {
27353       {
27354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (std::exception& e) {
27357       {
27358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (...) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27363       };
27364     }
27365   }
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27372   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27373
27374   arg1 = (Dali::KeyEvent *)jarg1;
27375   {
27376     try {
27377       delete arg1;
27378     } catch (std::out_of_range& e) {
27379       {
27380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27381       };
27382     } catch (std::exception& e) {
27383       {
27384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27385       };
27386     } catch (...) {
27387       {
27388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27389       };
27390     }
27391   }
27392 }
27393
27394
27395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27396   unsigned int jresult ;
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   bool result;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   {
27402     try {
27403       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27411       };
27412     } catch (...) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27415       };
27416     }
27417   }
27418   jresult = result;
27419   return jresult;
27420 }
27421
27422
27423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27424   unsigned int jresult ;
27425   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27426   bool result;
27427
27428   arg1 = (Dali::KeyEvent *)jarg1;
27429   {
27430     try {
27431       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27432     } catch (std::out_of_range& e) {
27433       {
27434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27435       };
27436     } catch (std::exception& e) {
27437       {
27438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27439       };
27440     } catch (...) {
27441       {
27442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27443       };
27444     }
27445   }
27446   jresult = result;
27447   return jresult;
27448 }
27449
27450
27451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27452   unsigned int jresult ;
27453   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27454   bool result;
27455
27456   arg1 = (Dali::KeyEvent *)jarg1;
27457   {
27458     try {
27459       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27460     } catch (std::out_of_range& e) {
27461       {
27462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (std::exception& e) {
27465       {
27466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474   jresult = result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27480   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27481   std::string *arg2 = 0 ;
27482
27483   arg1 = (Dali::KeyEvent *)jarg1;
27484   if (!jarg2) {
27485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27486     return ;
27487   }
27488   std::string arg2_str(jarg2);
27489   arg2 = &arg2_str;
27490   if (arg1) (arg1)->keyPressedName = *arg2;
27491
27492   //argout typemap for const std::string&
27493
27494 }
27495
27496
27497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27498   char * jresult ;
27499   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27500   std::string *result = 0 ;
27501
27502   arg1 = (Dali::KeyEvent *)jarg1;
27503   result = (std::string *) & ((arg1)->keyPressedName);
27504   jresult = SWIG_csharp_string_callback(result->c_str());
27505   return jresult;
27506 }
27507
27508
27509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27511   std::string *arg2 = 0 ;
27512
27513   arg1 = (Dali::KeyEvent *)jarg1;
27514   if (!jarg2) {
27515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27516     return ;
27517   }
27518   std::string arg2_str(jarg2);
27519   arg2 = &arg2_str;
27520   if (arg1) (arg1)->keyPressed = *arg2;
27521
27522   //argout typemap for const std::string&
27523
27524 }
27525
27526
27527 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27528   char * jresult ;
27529   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27530   std::string *result = 0 ;
27531
27532   arg1 = (Dali::KeyEvent *)jarg1;
27533   result = (std::string *) & ((arg1)->keyPressed);
27534   jresult = SWIG_csharp_string_callback(result->c_str());
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27540   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27541   int arg2 ;
27542
27543   arg1 = (Dali::KeyEvent *)jarg1;
27544   arg2 = (int)jarg2;
27545   if (arg1) (arg1)->keyCode = arg2;
27546 }
27547
27548
27549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27550   int jresult ;
27551   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27552   int result;
27553
27554   arg1 = (Dali::KeyEvent *)jarg1;
27555   result = (int) ((arg1)->keyCode);
27556   jresult = result;
27557   return jresult;
27558 }
27559
27560
27561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27562   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27563   int arg2 ;
27564
27565   arg1 = (Dali::KeyEvent *)jarg1;
27566   arg2 = (int)jarg2;
27567   if (arg1) (arg1)->keyModifier = arg2;
27568 }
27569
27570
27571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27572   int jresult ;
27573   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27574   int result;
27575
27576   arg1 = (Dali::KeyEvent *)jarg1;
27577   result = (int) ((arg1)->keyModifier);
27578   jresult = result;
27579   return jresult;
27580 }
27581
27582
27583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27584   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27585   unsigned long arg2 ;
27586
27587   arg1 = (Dali::KeyEvent *)jarg1;
27588   arg2 = (unsigned long)jarg2;
27589   if (arg1) (arg1)->time = arg2;
27590 }
27591
27592
27593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27594   unsigned long jresult ;
27595   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27596   unsigned long result;
27597
27598   arg1 = (Dali::KeyEvent *)jarg1;
27599   result = (unsigned long) ((arg1)->time);
27600   jresult = (unsigned long)result;
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27606   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27607   Dali::KeyEvent::State arg2 ;
27608
27609   arg1 = (Dali::KeyEvent *)jarg1;
27610   arg2 = (Dali::KeyEvent::State)jarg2;
27611   if (arg1) (arg1)->state = arg2;
27612 }
27613
27614
27615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27616   int jresult ;
27617   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27618   Dali::KeyEvent::State result;
27619
27620   arg1 = (Dali::KeyEvent *)jarg1;
27621   result = (Dali::KeyEvent::State) ((arg1)->state);
27622   jresult = (int)result;
27623   return jresult;
27624 }
27625
27626
27627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27628   void * jresult ;
27629   Dali::LongPressGestureDetector *result = 0 ;
27630
27631   {
27632     try {
27633       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27634     } catch (std::out_of_range& e) {
27635       {
27636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (std::exception& e) {
27639       {
27640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27645       };
27646     }
27647   }
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27654   void * jresult ;
27655   Dali::LongPressGestureDetector result;
27656
27657   {
27658     try {
27659       result = Dali::LongPressGestureDetector::New();
27660     } catch (std::out_of_range& e) {
27661       {
27662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27663       };
27664     } catch (std::exception& e) {
27665       {
27666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27667       };
27668     } catch (...) {
27669       {
27670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27671       };
27672     }
27673   }
27674   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27675   return jresult;
27676 }
27677
27678
27679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27680   void * jresult ;
27681   unsigned int arg1 ;
27682   Dali::LongPressGestureDetector result;
27683
27684   arg1 = (unsigned int)jarg1;
27685   {
27686     try {
27687       result = Dali::LongPressGestureDetector::New(arg1);
27688     } catch (std::out_of_range& e) {
27689       {
27690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27691       };
27692     } catch (std::exception& e) {
27693       {
27694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27695       };
27696     } catch (...) {
27697       {
27698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27699       };
27700     }
27701   }
27702   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27703   return jresult;
27704 }
27705
27706
27707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27708   void * jresult ;
27709   unsigned int arg1 ;
27710   unsigned int arg2 ;
27711   Dali::LongPressGestureDetector result;
27712
27713   arg1 = (unsigned int)jarg1;
27714   arg2 = (unsigned int)jarg2;
27715   {
27716     try {
27717       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27725       };
27726     } catch (...) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27729       };
27730     }
27731   }
27732   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27733   return jresult;
27734 }
27735
27736
27737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27738   void * jresult ;
27739   Dali::BaseHandle arg1 ;
27740   Dali::BaseHandle *argp1 ;
27741   Dali::LongPressGestureDetector result;
27742
27743   argp1 = (Dali::BaseHandle *)jarg1;
27744   if (!argp1) {
27745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27746     return 0;
27747   }
27748   arg1 = *argp1;
27749   {
27750     try {
27751       result = Dali::LongPressGestureDetector::DownCast(arg1);
27752     } catch (std::out_of_range& e) {
27753       {
27754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27755       };
27756     } catch (std::exception& e) {
27757       {
27758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (...) {
27761       {
27762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27763       };
27764     }
27765   }
27766   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27767   return jresult;
27768 }
27769
27770
27771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27772   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27773
27774   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27775   {
27776     try {
27777       delete arg1;
27778     } catch (std::out_of_range& e) {
27779       {
27780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27781       };
27782     } catch (std::exception& e) {
27783       {
27784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27785       };
27786     } catch (...) {
27787       {
27788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27789       };
27790     }
27791   }
27792 }
27793
27794
27795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27796   void * jresult ;
27797   Dali::LongPressGestureDetector *arg1 = 0 ;
27798   Dali::LongPressGestureDetector *result = 0 ;
27799
27800   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27801   if (!arg1) {
27802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27803     return 0;
27804   }
27805   {
27806     try {
27807       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27808     } catch (std::out_of_range& e) {
27809       {
27810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27811       };
27812     } catch (std::exception& e) {
27813       {
27814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27815       };
27816     } catch (...) {
27817       {
27818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27819       };
27820     }
27821   }
27822   jresult = (void *)result;
27823   return jresult;
27824 }
27825
27826
27827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27828   void * jresult ;
27829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27830   Dali::LongPressGestureDetector *arg2 = 0 ;
27831   Dali::LongPressGestureDetector *result = 0 ;
27832
27833   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27834   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27835   if (!arg2) {
27836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27837     return 0;
27838   }
27839   {
27840     try {
27841       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27849       };
27850     } catch (...) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27853       };
27854     }
27855   }
27856   jresult = (void *)result;
27857   return jresult;
27858 }
27859
27860
27861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27863   unsigned int arg2 ;
27864
27865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27866   arg2 = (unsigned int)jarg2;
27867   {
27868     try {
27869       (arg1)->SetTouchesRequired(arg2);
27870     } catch (std::out_of_range& e) {
27871       {
27872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27873       };
27874     } catch (std::exception& e) {
27875       {
27876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27877       };
27878     } catch (...) {
27879       {
27880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27881       };
27882     }
27883   }
27884 }
27885
27886
27887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27889   unsigned int arg2 ;
27890   unsigned int arg3 ;
27891
27892   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27893   arg2 = (unsigned int)jarg2;
27894   arg3 = (unsigned int)jarg3;
27895   {
27896     try {
27897       (arg1)->SetTouchesRequired(arg2,arg3);
27898     } catch (std::out_of_range& e) {
27899       {
27900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27901       };
27902     } catch (std::exception& e) {
27903       {
27904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27905       };
27906     } catch (...) {
27907       {
27908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27909       };
27910     }
27911   }
27912 }
27913
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27916   unsigned int jresult ;
27917   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27918   unsigned int result;
27919
27920   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27921   {
27922     try {
27923       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (...) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27935       };
27936     }
27937   }
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27944   unsigned int jresult ;
27945   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27946   unsigned int result;
27947
27948   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27949   {
27950     try {
27951       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27952     } catch (std::out_of_range& e) {
27953       {
27954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27955       };
27956     } catch (std::exception& e) {
27957       {
27958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (...) {
27961       {
27962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27963       };
27964     }
27965   }
27966   jresult = result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27972   void * jresult ;
27973   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27974   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27975
27976   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27977   {
27978     try {
27979       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27980     } catch (std::out_of_range& e) {
27981       {
27982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (std::exception& e) {
27985       {
27986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994   jresult = (void *)result;
27995   return jresult;
27996 }
27997
27998
27999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
28000   void * jresult ;
28001   Dali::Gesture::State arg1 ;
28002   Dali::LongPressGesture *result = 0 ;
28003
28004   arg1 = (Dali::Gesture::State)jarg1;
28005   {
28006     try {
28007       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28008     } catch (std::out_of_range& e) {
28009       {
28010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28011       };
28012     } catch (std::exception& e) {
28013       {
28014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28015       };
28016     } catch (...) {
28017       {
28018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28019       };
28020     }
28021   }
28022   jresult = (void *)result;
28023   return jresult;
28024 }
28025
28026
28027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28028   void * jresult ;
28029   Dali::LongPressGesture *arg1 = 0 ;
28030   Dali::LongPressGesture *result = 0 ;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   if (!arg1) {
28034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28035     return 0;
28036   }
28037   {
28038     try {
28039       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28040     } catch (std::out_of_range& e) {
28041       {
28042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28043       };
28044     } catch (std::exception& e) {
28045       {
28046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28047       };
28048     } catch (...) {
28049       {
28050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28051       };
28052     }
28053   }
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28060   void * jresult ;
28061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28062   Dali::LongPressGesture *arg2 = 0 ;
28063   Dali::LongPressGesture *result = 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (Dali::LongPressGesture *)jarg2;
28067   if (!arg2) {
28068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28069     return 0;
28070   }
28071   {
28072     try {
28073       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28074     } catch (std::out_of_range& e) {
28075       {
28076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28077       };
28078     } catch (std::exception& e) {
28079       {
28080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28081       };
28082     } catch (...) {
28083       {
28084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28085       };
28086     }
28087   }
28088   jresult = (void *)result;
28089   return jresult;
28090 }
28091
28092
28093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28094   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28095
28096   arg1 = (Dali::LongPressGesture *)jarg1;
28097   {
28098     try {
28099       delete arg1;
28100     } catch (std::out_of_range& e) {
28101       {
28102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28103       };
28104     } catch (std::exception& e) {
28105       {
28106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28107       };
28108     } catch (...) {
28109       {
28110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28111       };
28112     }
28113   }
28114 }
28115
28116
28117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28118   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28119   unsigned int arg2 ;
28120
28121   arg1 = (Dali::LongPressGesture *)jarg1;
28122   arg2 = (unsigned int)jarg2;
28123   if (arg1) (arg1)->numberOfTouches = arg2;
28124 }
28125
28126
28127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28128   unsigned int jresult ;
28129   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28130   unsigned int result;
28131
28132   arg1 = (Dali::LongPressGesture *)jarg1;
28133   result = (unsigned int) ((arg1)->numberOfTouches);
28134   jresult = result;
28135   return jresult;
28136 }
28137
28138
28139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28140   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28141   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28142
28143   arg1 = (Dali::LongPressGesture *)jarg1;
28144   arg2 = (Dali::Vector2 *)jarg2;
28145   if (arg1) (arg1)->screenPoint = *arg2;
28146 }
28147
28148
28149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28150   void * jresult ;
28151   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28152   Dali::Vector2 *result = 0 ;
28153
28154   arg1 = (Dali::LongPressGesture *)jarg1;
28155   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28156   jresult = (void *)result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28162   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28164
28165   arg1 = (Dali::LongPressGesture *)jarg1;
28166   arg2 = (Dali::Vector2 *)jarg2;
28167   if (arg1) (arg1)->localPoint = *arg2;
28168 }
28169
28170
28171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28172   void * jresult ;
28173   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28174   Dali::Vector2 *result = 0 ;
28175
28176   arg1 = (Dali::LongPressGesture *)jarg1;
28177   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28178   jresult = (void *)result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28184   void * jresult ;
28185   Dali::WheelEvent *result = 0 ;
28186
28187   {
28188     try {
28189       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28190     } catch (std::out_of_range& e) {
28191       {
28192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28193       };
28194     } catch (std::exception& e) {
28195       {
28196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28197       };
28198     } catch (...) {
28199       {
28200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28201       };
28202     }
28203   }
28204   jresult = (void *)result;
28205   return jresult;
28206 }
28207
28208
28209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28210   void * jresult ;
28211   Dali::WheelEvent::Type arg1 ;
28212   int arg2 ;
28213   unsigned int arg3 ;
28214   Dali::Vector2 arg4 ;
28215   int arg5 ;
28216   unsigned int arg6 ;
28217   Dali::Vector2 *argp4 ;
28218   Dali::WheelEvent *result = 0 ;
28219
28220   arg1 = (Dali::WheelEvent::Type)jarg1;
28221   arg2 = (int)jarg2;
28222   arg3 = (unsigned int)jarg3;
28223   argp4 = (Dali::Vector2 *)jarg4;
28224   if (!argp4) {
28225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28226     return 0;
28227   }
28228   arg4 = *argp4;
28229   arg5 = (int)jarg5;
28230   arg6 = (unsigned int)jarg6;
28231   {
28232     try {
28233       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28234     } catch (std::out_of_range& e) {
28235       {
28236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (std::exception& e) {
28239       {
28240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28241       };
28242     } catch (...) {
28243       {
28244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28245       };
28246     }
28247   }
28248   jresult = (void *)result;
28249   return jresult;
28250 }
28251
28252
28253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28254   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28255
28256   arg1 = (Dali::WheelEvent *)jarg1;
28257   {
28258     try {
28259       delete arg1;
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28267       };
28268     } catch (...) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28271       };
28272     }
28273   }
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28278   unsigned int jresult ;
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   bool result;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   {
28284     try {
28285       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28286     } catch (std::out_of_range& e) {
28287       {
28288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28289       };
28290     } catch (std::exception& e) {
28291       {
28292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28293       };
28294     } catch (...) {
28295       {
28296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28297       };
28298     }
28299   }
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28306   unsigned int jresult ;
28307   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28308   bool result;
28309
28310   arg1 = (Dali::WheelEvent *)jarg1;
28311   {
28312     try {
28313       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28314     } catch (std::out_of_range& e) {
28315       {
28316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (std::exception& e) {
28319       {
28320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28325       };
28326     }
28327   }
28328   jresult = result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28334   unsigned int jresult ;
28335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28336   bool result;
28337
28338   arg1 = (Dali::WheelEvent *)jarg1;
28339   {
28340     try {
28341       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28342     } catch (std::out_of_range& e) {
28343       {
28344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28345       };
28346     } catch (std::exception& e) {
28347       {
28348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28349       };
28350     } catch (...) {
28351       {
28352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28353       };
28354     }
28355   }
28356   jresult = result;
28357   return jresult;
28358 }
28359
28360
28361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28362   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28363   Dali::WheelEvent::Type arg2 ;
28364
28365   arg1 = (Dali::WheelEvent *)jarg1;
28366   arg2 = (Dali::WheelEvent::Type)jarg2;
28367   if (arg1) (arg1)->type = arg2;
28368 }
28369
28370
28371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28372   int jresult ;
28373   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28374   Dali::WheelEvent::Type result;
28375
28376   arg1 = (Dali::WheelEvent *)jarg1;
28377   result = (Dali::WheelEvent::Type) ((arg1)->type);
28378   jresult = (int)result;
28379   return jresult;
28380 }
28381
28382
28383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28384   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28385   int arg2 ;
28386
28387   arg1 = (Dali::WheelEvent *)jarg1;
28388   arg2 = (int)jarg2;
28389   if (arg1) (arg1)->direction = arg2;
28390 }
28391
28392
28393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28394   int jresult ;
28395   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28396   int result;
28397
28398   arg1 = (Dali::WheelEvent *)jarg1;
28399   result = (int) ((arg1)->direction);
28400   jresult = result;
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28406   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28407   unsigned int arg2 ;
28408
28409   arg1 = (Dali::WheelEvent *)jarg1;
28410   arg2 = (unsigned int)jarg2;
28411   if (arg1) (arg1)->modifiers = arg2;
28412 }
28413
28414
28415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28416   unsigned int jresult ;
28417   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28418   unsigned int result;
28419
28420   arg1 = (Dali::WheelEvent *)jarg1;
28421   result = (unsigned int) ((arg1)->modifiers);
28422   jresult = result;
28423   return jresult;
28424 }
28425
28426
28427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28428   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28429   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28430
28431   arg1 = (Dali::WheelEvent *)jarg1;
28432   arg2 = (Dali::Vector2 *)jarg2;
28433   if (arg1) (arg1)->point = *arg2;
28434 }
28435
28436
28437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28438   void * jresult ;
28439   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28440   Dali::Vector2 *result = 0 ;
28441
28442   arg1 = (Dali::WheelEvent *)jarg1;
28443   result = (Dali::Vector2 *)& ((arg1)->point);
28444   jresult = (void *)result;
28445   return jresult;
28446 }
28447
28448
28449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28450   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28451   int arg2 ;
28452
28453   arg1 = (Dali::WheelEvent *)jarg1;
28454   arg2 = (int)jarg2;
28455   if (arg1) (arg1)->z = arg2;
28456 }
28457
28458
28459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28460   int jresult ;
28461   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28462   int result;
28463
28464   arg1 = (Dali::WheelEvent *)jarg1;
28465   result = (int) ((arg1)->z);
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28472   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28473   unsigned int arg2 ;
28474
28475   arg1 = (Dali::WheelEvent *)jarg1;
28476   arg2 = (unsigned int)jarg2;
28477   if (arg1) (arg1)->timeStamp = arg2;
28478 }
28479
28480
28481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28482   unsigned int jresult ;
28483   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28484   unsigned int result;
28485
28486   arg1 = (Dali::WheelEvent *)jarg1;
28487   result = (unsigned int) ((arg1)->timeStamp);
28488   jresult = result;
28489   return jresult;
28490 }
28491
28492 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28493   char * jresult ;
28494   Dali::KeyEvent *arg1 = 0 ;
28495   std::string result;
28496
28497   arg1 = (Dali::KeyEvent *)jarg1;
28498   if (!arg1) {
28499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28500     return 0;
28501   }
28502   {
28503     try {
28504       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28505     } catch (std::out_of_range& e) {
28506       {
28507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28508       };
28509     } catch (std::exception& e) {
28510       {
28511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (...) {
28514       {
28515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28516       };
28517     }
28518   }
28519   jresult = SWIG_csharp_string_callback((&result)->c_str());
28520   return jresult;
28521 }
28522
28523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28524   int jresult ;
28525   Dali::KeyEvent *arg1 = 0 ;
28526   Dali::DevelKeyEvent::DeviceClass::Type result;
28527
28528   arg1 = (Dali::KeyEvent *)jarg1;
28529   if (!arg1) {
28530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28531     return 0;
28532   }
28533   {
28534     try {
28535       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28536     } catch (std::out_of_range& e) {
28537       {
28538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28539       };
28540     } catch (std::exception& e) {
28541       {
28542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28543       };
28544     } catch (...) {
28545       {
28546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28547       };
28548     }
28549   }
28550   jresult = (int)result;
28551   return jresult;
28552 }
28553
28554
28555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28556   Dali::Actor arg1 ;
28557   Dali::Actor *argp1 ;
28558
28559   argp1 = (Dali::Actor *)jarg1;
28560   if (!argp1) {
28561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28562     return ;
28563   }
28564   arg1 = *argp1;
28565   {
28566     try {
28567       Dali::DevelActor::Raise(arg1);
28568     } catch (std::out_of_range& e) {
28569       {
28570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28571       };
28572     } catch (std::exception& e) {
28573       {
28574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28579       };
28580     }
28581   }
28582 }
28583
28584
28585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28586   Dali::Actor arg1 ;
28587   Dali::Actor *argp1 ;
28588
28589   argp1 = (Dali::Actor *)jarg1;
28590   if (!argp1) {
28591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28592     return ;
28593   }
28594   arg1 = *argp1;
28595   {
28596     try {
28597       Dali::DevelActor::Lower(arg1);
28598     } catch (std::out_of_range& e) {
28599       {
28600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28601       };
28602     } catch (std::exception& e) {
28603       {
28604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28605       };
28606     } catch (...) {
28607       {
28608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28609       };
28610     }
28611   }
28612 }
28613
28614
28615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28616   Dali::Actor arg1 ;
28617   Dali::Actor *argp1 ;
28618
28619   argp1 = (Dali::Actor *)jarg1;
28620   if (!argp1) {
28621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28622     return ;
28623   }
28624   arg1 = *argp1;
28625   {
28626     try {
28627       Dali::DevelActor::RaiseToTop(arg1);
28628     } catch (std::out_of_range& e) {
28629       {
28630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28631       };
28632     } catch (std::exception& e) {
28633       {
28634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28635       };
28636     } catch (...) {
28637       {
28638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28639       };
28640     }
28641   }
28642 }
28643
28644
28645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28646   Dali::Actor arg1 ;
28647   Dali::Actor *argp1 ;
28648
28649   argp1 = (Dali::Actor *)jarg1;
28650   if (!argp1) {
28651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28652     return ;
28653   }
28654   arg1 = *argp1;
28655   {
28656     try {
28657       Dali::DevelActor::LowerToBottom(arg1);
28658     } catch (std::out_of_range& e) {
28659       {
28660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28661       };
28662     } catch (std::exception& e) {
28663       {
28664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28669       };
28670     }
28671   }
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28676   Dali::Actor arg1 ;
28677   Dali::Actor arg2 ;
28678   Dali::Actor *argp1 ;
28679   Dali::Actor *argp2 ;
28680
28681   argp1 = (Dali::Actor *)jarg1;
28682   if (!argp1) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28684     return ;
28685   }
28686   arg1 = *argp1;
28687   argp2 = (Dali::Actor *)jarg2;
28688   if (!argp2) {
28689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28690     return ;
28691   }
28692   arg2 = *argp2;
28693   {
28694     try {
28695       Dali::DevelActor::RaiseAbove(arg1,arg2);
28696     } catch (std::out_of_range& e) {
28697       {
28698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28699       };
28700     } catch (std::exception& e) {
28701       {
28702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28703       };
28704     } catch (...) {
28705       {
28706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28707       };
28708     }
28709   }
28710 }
28711
28712
28713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28714   Dali::Actor arg1 ;
28715   Dali::Actor arg2 ;
28716   Dali::Actor *argp1 ;
28717   Dali::Actor *argp2 ;
28718
28719   argp1 = (Dali::Actor *)jarg1;
28720   if (!argp1) {
28721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28722     return ;
28723   }
28724   arg1 = *argp1;
28725   argp2 = (Dali::Actor *)jarg2;
28726   if (!argp2) {
28727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28728     return ;
28729   }
28730   arg2 = *argp2;
28731   {
28732     try {
28733       Dali::DevelActor::LowerBelow(arg1,arg2);
28734     } catch (std::out_of_range& e) {
28735       {
28736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28737       };
28738     } catch (std::exception& e) {
28739       {
28740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28741       };
28742     } catch (...) {
28743       {
28744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28745       };
28746     }
28747   }
28748 }
28749
28750
28751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28752   void * jresult ;
28753   Dali::Actor arg1 ;
28754   Dali::Actor *argp1 ;
28755   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28756
28757   argp1 = (Dali::Actor *)jarg1;
28758   if (!argp1) {
28759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28760     return 0;
28761   }
28762   arg1 = *argp1;
28763   {
28764     try {
28765       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28766     } catch (std::out_of_range& e) {
28767       {
28768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28769       };
28770     } catch (std::exception& e) {
28771       {
28772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28773       };
28774     } catch (...) {
28775       {
28776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28777       };
28778     }
28779   }
28780   jresult = (void *)result;
28781   return jresult;
28782 }
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::SIZE;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::POSITION;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::POSITION_X;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::POSITION_Y;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::POSITION_Z;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::WORLD_POSITION;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::ORIENTATION;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::SCALE;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::SCALE_X;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::SCALE_Y;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::SCALE_Z;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::WORLD_SCALE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::VISIBLE;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::COLOR;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29075   int jresult ;
29076   int result;
29077
29078   result = (int)Dali::Actor::Property::COLOR_RED;
29079   jresult = (int)result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29085   int jresult ;
29086   int result;
29087
29088   result = (int)Dali::Actor::Property::COLOR_GREEN;
29089   jresult = (int)result;
29090   return jresult;
29091 }
29092
29093
29094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29095   int jresult ;
29096   int result;
29097
29098   result = (int)Dali::Actor::Property::COLOR_BLUE;
29099   jresult = (int)result;
29100   return jresult;
29101 }
29102
29103
29104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29105   int jresult ;
29106   int result;
29107
29108   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29109   jresult = (int)result;
29110   return jresult;
29111 }
29112
29113
29114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29115   int jresult ;
29116   int result;
29117
29118   result = (int)Dali::Actor::Property::WORLD_COLOR;
29119   jresult = (int)result;
29120   return jresult;
29121 }
29122
29123
29124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29125   int jresult ;
29126   int result;
29127
29128   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29129   jresult = (int)result;
29130   return jresult;
29131 }
29132
29133
29134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29135   int jresult ;
29136   int result;
29137
29138   result = (int)Dali::Actor::Property::NAME;
29139   jresult = (int)result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29145   int jresult ;
29146   int result;
29147
29148   result = (int)Dali::Actor::Property::SENSITIVE;
29149   jresult = (int)result;
29150   return jresult;
29151 }
29152
29153
29154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29155   int jresult ;
29156   int result;
29157
29158   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29159   jresult = (int)result;
29160   return jresult;
29161 }
29162
29163
29164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29165   int jresult ;
29166   int result;
29167
29168   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29175   int jresult ;
29176   int result;
29177
29178   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29179   jresult = (int)result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29185   int jresult ;
29186   int result;
29187
29188   result = (int)Dali::Actor::Property::COLOR_MODE;
29189   jresult = (int)result;
29190   return jresult;
29191 }
29192
29193
29194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29195   int jresult ;
29196   int result;
29197
29198   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29199   jresult = (int)result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29205   int jresult ;
29206   int result;
29207
29208   result = (int)Dali::Actor::Property::DRAW_MODE;
29209   jresult = (int)result;
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29215   int jresult ;
29216   int result;
29217
29218   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29219   jresult = (int)result;
29220   return jresult;
29221 }
29222
29223
29224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29225   int jresult ;
29226   int result;
29227
29228   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29229   jresult = (int)result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29235   int jresult ;
29236   int result;
29237
29238   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29239   jresult = (int)result;
29240   return jresult;
29241 }
29242
29243
29244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29245   int jresult ;
29246   int result;
29247
29248   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29249   jresult = (int)result;
29250   return jresult;
29251 }
29252
29253
29254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29255   int jresult ;
29256   int result;
29257
29258   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29259   jresult = (int)result;
29260   return jresult;
29261 }
29262
29263
29264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29265   int jresult ;
29266   int result;
29267
29268   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29269   jresult = (int)result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29275   int jresult ;
29276   int result;
29277
29278   result = (int)Dali::Actor::Property::PADDING;
29279   jresult = (int)result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29285   int jresult ;
29286   int result;
29287
29288   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29289   jresult = (int)result;
29290   return jresult;
29291 }
29292
29293
29294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29295   int jresult ;
29296   int result;
29297
29298   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29299   jresult = (int)result;
29300   return jresult;
29301 }
29302
29303
29304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29305   int jresult ;
29306   int result;
29307
29308   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29309   jresult = (int)result;
29310   return jresult;
29311 }
29312
29313
29314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29315   int jresult ;
29316   int result;
29317
29318   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29319   jresult = (int)result;
29320   return jresult;
29321 }
29322
29323
29324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29325   void * jresult ;
29326   Dali::Actor::Property *result = 0 ;
29327
29328   {
29329     try {
29330       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29331     } catch (std::out_of_range& e) {
29332       {
29333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29334       };
29335     } catch (std::exception& e) {
29336       {
29337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29338       };
29339     } catch (...) {
29340       {
29341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29342       };
29343     }
29344   }
29345   jresult = (void *)result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29351   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29352
29353   arg1 = (Dali::Actor::Property *)jarg1;
29354   {
29355     try {
29356       delete arg1;
29357     } catch (std::out_of_range& e) {
29358       {
29359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (std::exception& e) {
29362       {
29363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371 }
29372
29373
29374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29375   void * jresult ;
29376   Dali::Actor *result = 0 ;
29377
29378   {
29379     try {
29380       result = (Dali::Actor *)new Dali::Actor();
29381     } catch (std::out_of_range& e) {
29382       {
29383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (std::exception& e) {
29386       {
29387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29401   void * jresult ;
29402   Dali::Actor result;
29403
29404   {
29405     try {
29406       result = Dali::Actor::New();
29407     } catch (std::out_of_range& e) {
29408       {
29409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29410       };
29411     } catch (std::exception& e) {
29412       {
29413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29414       };
29415     } catch (...) {
29416       {
29417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29418       };
29419     }
29420   }
29421   jresult = new Dali::Actor((const Dali::Actor &)result);
29422   return jresult;
29423 }
29424
29425
29426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29427   void * jresult ;
29428   Dali::BaseHandle arg1 ;
29429   Dali::BaseHandle *argp1 ;
29430   Dali::Actor result;
29431
29432   argp1 = (Dali::BaseHandle *)jarg1;
29433   if (!argp1) {
29434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29435     return 0;
29436   }
29437   arg1 = *argp1;
29438   {
29439     try {
29440       result = Dali::Actor::DownCast(arg1);
29441     } catch (std::out_of_range& e) {
29442       {
29443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29444       };
29445     } catch (std::exception& e) {
29446       {
29447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (...) {
29450       {
29451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29452       };
29453     }
29454   }
29455   jresult = new Dali::Actor((const Dali::Actor &)result);
29456   return jresult;
29457 }
29458
29459
29460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29462
29463   arg1 = (Dali::Actor *)jarg1;
29464   {
29465     try {
29466       delete arg1;
29467     } catch (std::out_of_range& e) {
29468       {
29469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29470       };
29471     } catch (std::exception& e) {
29472       {
29473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29474       };
29475     } catch (...) {
29476       {
29477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29478       };
29479     }
29480   }
29481 }
29482
29483
29484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29485   void * jresult ;
29486   Dali::Actor *arg1 = 0 ;
29487   Dali::Actor *result = 0 ;
29488
29489   arg1 = (Dali::Actor *)jarg1;
29490   if (!arg1) {
29491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29492     return 0;
29493   }
29494   {
29495     try {
29496       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29508       };
29509     }
29510   }
29511   jresult = (void *)result;
29512   return jresult;
29513 }
29514
29515
29516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29517   void * jresult ;
29518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29519   Dali::Actor *arg2 = 0 ;
29520   Dali::Actor *result = 0 ;
29521
29522   arg1 = (Dali::Actor *)jarg1;
29523   arg2 = (Dali::Actor *)jarg2;
29524   if (!arg2) {
29525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29526     return 0;
29527   }
29528   {
29529     try {
29530       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (...) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29542       };
29543     }
29544   }
29545   jresult = (void *)result;
29546   return jresult;
29547 }
29548
29549
29550 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29551   char * jresult ;
29552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29553   std::string *result = 0 ;
29554
29555   arg1 = (Dali::Actor *)jarg1;
29556   {
29557     try {
29558       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29566       };
29567     } catch (...) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29570       };
29571     }
29572   }
29573   jresult = SWIG_csharp_string_callback(result->c_str());
29574   return jresult;
29575 }
29576
29577
29578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29580   std::string *arg2 = 0 ;
29581
29582   arg1 = (Dali::Actor *)jarg1;
29583   if (!jarg2) {
29584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29585     return ;
29586   }
29587   std::string arg2_str(jarg2);
29588   arg2 = &arg2_str;
29589   {
29590     try {
29591       (arg1)->SetName((std::string const &)*arg2);
29592     } catch (std::out_of_range& e) {
29593       {
29594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29595       };
29596     } catch (std::exception& e) {
29597       {
29598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29599       };
29600     } catch (...) {
29601       {
29602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29603       };
29604     }
29605   }
29606
29607   //argout typemap for const std::string&
29608
29609 }
29610
29611
29612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29613   unsigned int jresult ;
29614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29615   unsigned int result;
29616
29617   arg1 = (Dali::Actor *)jarg1;
29618   {
29619     try {
29620       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29621     } catch (std::out_of_range& e) {
29622       {
29623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29624       };
29625     } catch (std::exception& e) {
29626       {
29627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29628       };
29629     } catch (...) {
29630       {
29631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29632       };
29633     }
29634   }
29635   jresult = result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29641   unsigned int jresult ;
29642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29643   bool result;
29644
29645   arg1 = (Dali::Actor *)jarg1;
29646   {
29647     try {
29648       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29649     } catch (std::out_of_range& e) {
29650       {
29651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29652       };
29653     } catch (std::exception& e) {
29654       {
29655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (...) {
29658       {
29659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29660       };
29661     }
29662   }
29663   jresult = result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29669   unsigned int jresult ;
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   bool result;
29672
29673   arg1 = (Dali::Actor *)jarg1;
29674   {
29675     try {
29676       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29677     } catch (std::out_of_range& e) {
29678       {
29679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29680       };
29681     } catch (std::exception& e) {
29682       {
29683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29684       };
29685     } catch (...) {
29686       {
29687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29688       };
29689     }
29690   }
29691   jresult = result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29697   unsigned int jresult ;
29698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29699   bool result;
29700
29701   arg1 = (Dali::Actor *)jarg1;
29702   {
29703     try {
29704       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29705     } catch (std::out_of_range& e) {
29706       {
29707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (std::exception& e) {
29710       {
29711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719   jresult = result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29725   void * jresult ;
29726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29727   Dali::Layer result;
29728
29729   arg1 = (Dali::Actor *)jarg1;
29730   {
29731     try {
29732       result = (arg1)->GetLayer();
29733     } catch (std::out_of_range& e) {
29734       {
29735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29736       };
29737     } catch (std::exception& e) {
29738       {
29739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29740       };
29741     } catch (...) {
29742       {
29743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29744       };
29745     }
29746   }
29747   jresult = new Dali::Layer((const Dali::Layer &)result);
29748   return jresult;
29749 }
29750
29751
29752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29754   Dali::Actor arg2 ;
29755   Dali::Actor *argp2 ;
29756
29757   arg1 = (Dali::Actor *)jarg1;
29758   argp2 = (Dali::Actor *)jarg2;
29759   if (!argp2) {
29760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29761     return ;
29762   }
29763   arg2 = *argp2;
29764   {
29765     try {
29766       (arg1)->Add(arg2);
29767     } catch (std::out_of_range& e) {
29768       {
29769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29770       };
29771     } catch (std::exception& e) {
29772       {
29773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29774       };
29775     } catch (...) {
29776       {
29777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29778       };
29779     }
29780   }
29781 }
29782
29783
29784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29786   Dali::Actor arg2 ;
29787   Dali::Actor *argp2 ;
29788
29789   arg1 = (Dali::Actor *)jarg1;
29790   argp2 = (Dali::Actor *)jarg2;
29791   if (!argp2) {
29792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29793     return ;
29794   }
29795   arg2 = *argp2;
29796   {
29797     try {
29798       (arg1)->Remove(arg2);
29799     } catch (std::out_of_range& e) {
29800       {
29801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29802       };
29803     } catch (std::exception& e) {
29804       {
29805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29806       };
29807     } catch (...) {
29808       {
29809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29810       };
29811     }
29812   }
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29818
29819   arg1 = (Dali::Actor *)jarg1;
29820   {
29821     try {
29822       (arg1)->Unparent();
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (...) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29834       };
29835     }
29836   }
29837 }
29838
29839
29840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29841   unsigned int jresult ;
29842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29843   unsigned int result;
29844
29845   arg1 = (Dali::Actor *)jarg1;
29846   {
29847     try {
29848       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29849     } catch (std::out_of_range& e) {
29850       {
29851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (std::exception& e) {
29854       {
29855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29856       };
29857     } catch (...) {
29858       {
29859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29860       };
29861     }
29862   }
29863   jresult = result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29869   void * jresult ;
29870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29871   unsigned int arg2 ;
29872   Dali::Actor result;
29873
29874   arg1 = (Dali::Actor *)jarg1;
29875   arg2 = (unsigned int)jarg2;
29876   {
29877     try {
29878       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29879     } catch (std::out_of_range& e) {
29880       {
29881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (std::exception& e) {
29884       {
29885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29886       };
29887     } catch (...) {
29888       {
29889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29890       };
29891     }
29892   }
29893   jresult = new Dali::Actor((const Dali::Actor &)result);
29894   return jresult;
29895 }
29896
29897
29898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29899   void * jresult ;
29900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29901   std::string *arg2 = 0 ;
29902   Dali::Actor result;
29903
29904   arg1 = (Dali::Actor *)jarg1;
29905   if (!jarg2) {
29906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29907     return 0;
29908   }
29909   std::string arg2_str(jarg2);
29910   arg2 = &arg2_str;
29911   {
29912     try {
29913       result = (arg1)->FindChildByName((std::string const &)*arg2);
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (...) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29925       };
29926     }
29927   }
29928   jresult = new Dali::Actor((const Dali::Actor &)result);
29929
29930   //argout typemap for const std::string&
29931
29932   return jresult;
29933 }
29934
29935
29936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29937   void * jresult ;
29938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29939   unsigned int arg2 ;
29940   Dali::Actor result;
29941
29942   arg1 = (Dali::Actor *)jarg1;
29943   arg2 = (unsigned int)jarg2;
29944   {
29945     try {
29946       result = (arg1)->FindChildById(arg2);
29947     } catch (std::out_of_range& e) {
29948       {
29949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (std::exception& e) {
29952       {
29953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961   jresult = new Dali::Actor((const Dali::Actor &)result);
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29967   void * jresult ;
29968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29969   Dali::Actor result;
29970
29971   arg1 = (Dali::Actor *)jarg1;
29972   {
29973     try {
29974       result = ((Dali::Actor const *)arg1)->GetParent();
29975     } catch (std::out_of_range& e) {
29976       {
29977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29978       };
29979     } catch (std::exception& e) {
29980       {
29981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (...) {
29984       {
29985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29986       };
29987     }
29988   }
29989   jresult = new Dali::Actor((const Dali::Actor &)result);
29990   return jresult;
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29996   Dali::Vector3 *arg2 = 0 ;
29997
29998   arg1 = (Dali::Actor *)jarg1;
29999   arg2 = (Dali::Vector3 *)jarg2;
30000   if (!arg2) {
30001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30002     return ;
30003   }
30004   {
30005     try {
30006       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30014       };
30015     } catch (...) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30018       };
30019     }
30020   }
30021 }
30022
30023
30024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30025   void * jresult ;
30026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30027   Dali::Vector3 result;
30028
30029   arg1 = (Dali::Actor *)jarg1;
30030   {
30031     try {
30032       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (...) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30044       };
30045     }
30046   }
30047   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30048   return jresult;
30049 }
30050
30051
30052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30054   Dali::Vector3 *arg2 = 0 ;
30055
30056   arg1 = (Dali::Actor *)jarg1;
30057   arg2 = (Dali::Vector3 *)jarg2;
30058   if (!arg2) {
30059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30060     return ;
30061   }
30062   {
30063     try {
30064       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30065     } catch (std::out_of_range& e) {
30066       {
30067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30068       };
30069     } catch (std::exception& e) {
30070       {
30071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30072       };
30073     } catch (...) {
30074       {
30075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30076       };
30077     }
30078   }
30079 }
30080
30081
30082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30083   void * jresult ;
30084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30085   Dali::Vector3 result;
30086
30087   arg1 = (Dali::Actor *)jarg1;
30088   {
30089     try {
30090       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30091     } catch (std::out_of_range& e) {
30092       {
30093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30094       };
30095     } catch (std::exception& e) {
30096       {
30097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30102       };
30103     }
30104   }
30105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30112   float arg2 ;
30113   float arg3 ;
30114
30115   arg1 = (Dali::Actor *)jarg1;
30116   arg2 = (float)jarg2;
30117   arg3 = (float)jarg3;
30118   {
30119     try {
30120       (arg1)->SetSize(arg2,arg3);
30121     } catch (std::out_of_range& e) {
30122       {
30123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30124       };
30125     } catch (std::exception& e) {
30126       {
30127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30132       };
30133     }
30134   }
30135 }
30136
30137
30138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30140   float arg2 ;
30141   float arg3 ;
30142   float arg4 ;
30143
30144   arg1 = (Dali::Actor *)jarg1;
30145   arg2 = (float)jarg2;
30146   arg3 = (float)jarg3;
30147   arg4 = (float)jarg4;
30148   {
30149     try {
30150       (arg1)->SetSize(arg2,arg3,arg4);
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30158       };
30159     } catch (...) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30162       };
30163     }
30164   }
30165 }
30166
30167
30168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30170   Dali::Vector2 *arg2 = 0 ;
30171
30172   arg1 = (Dali::Actor *)jarg1;
30173   arg2 = (Dali::Vector2 *)jarg2;
30174   if (!arg2) {
30175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30176     return ;
30177   }
30178   {
30179     try {
30180       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30181     } catch (std::out_of_range& e) {
30182       {
30183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30184       };
30185     } catch (std::exception& e) {
30186       {
30187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30192       };
30193     }
30194   }
30195 }
30196
30197
30198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30200   Dali::Vector3 *arg2 = 0 ;
30201
30202   arg1 = (Dali::Actor *)jarg1;
30203   arg2 = (Dali::Vector3 *)jarg2;
30204   if (!arg2) {
30205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30206     return ;
30207   }
30208   {
30209     try {
30210       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30211     } catch (std::out_of_range& e) {
30212       {
30213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30214       };
30215     } catch (std::exception& e) {
30216       {
30217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30218       };
30219     } catch (...) {
30220       {
30221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30222       };
30223     }
30224   }
30225 }
30226
30227
30228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30229   void * jresult ;
30230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30231   Dali::Vector3 result;
30232
30233   arg1 = (Dali::Actor *)jarg1;
30234   {
30235     try {
30236       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30237     } catch (std::out_of_range& e) {
30238       {
30239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30240       };
30241     } catch (std::exception& e) {
30242       {
30243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (...) {
30246       {
30247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30248       };
30249     }
30250   }
30251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30252   return jresult;
30253 }
30254
30255
30256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30257   void * jresult ;
30258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30259   Dali::Vector3 result;
30260
30261   arg1 = (Dali::Actor *)jarg1;
30262   {
30263     try {
30264       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30265     } catch (std::out_of_range& e) {
30266       {
30267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30268       };
30269     } catch (std::exception& e) {
30270       {
30271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30276       };
30277     }
30278   }
30279   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30280   return jresult;
30281 }
30282
30283
30284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30285   void * jresult ;
30286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30287   Dali::Vector3 result;
30288
30289   arg1 = (Dali::Actor *)jarg1;
30290   {
30291     try {
30292       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30304       };
30305     }
30306   }
30307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30308   return jresult;
30309 }
30310
30311
30312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30314   float arg2 ;
30315   float arg3 ;
30316
30317   arg1 = (Dali::Actor *)jarg1;
30318   arg2 = (float)jarg2;
30319   arg3 = (float)jarg3;
30320   {
30321     try {
30322       (arg1)->SetPosition(arg2,arg3);
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30334       };
30335     }
30336   }
30337 }
30338
30339
30340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30342   float arg2 ;
30343   float arg3 ;
30344   float arg4 ;
30345
30346   arg1 = (Dali::Actor *)jarg1;
30347   arg2 = (float)jarg2;
30348   arg3 = (float)jarg3;
30349   arg4 = (float)jarg4;
30350   {
30351     try {
30352       (arg1)->SetPosition(arg2,arg3,arg4);
30353     } catch (std::out_of_range& e) {
30354       {
30355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30356       };
30357     } catch (std::exception& e) {
30358       {
30359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30364       };
30365     }
30366   }
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30372   Dali::Vector3 *arg2 = 0 ;
30373
30374   arg1 = (Dali::Actor *)jarg1;
30375   arg2 = (Dali::Vector3 *)jarg2;
30376   if (!arg2) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30378     return ;
30379   }
30380   {
30381     try {
30382       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30383     } catch (std::out_of_range& e) {
30384       {
30385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30386       };
30387     } catch (std::exception& e) {
30388       {
30389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30390       };
30391     } catch (...) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30394       };
30395     }
30396   }
30397 }
30398
30399
30400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30402   float arg2 ;
30403
30404   arg1 = (Dali::Actor *)jarg1;
30405   arg2 = (float)jarg2;
30406   {
30407     try {
30408       (arg1)->SetX(arg2);
30409     } catch (std::out_of_range& e) {
30410       {
30411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30412       };
30413     } catch (std::exception& e) {
30414       {
30415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30420       };
30421     }
30422   }
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   float arg2 ;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   arg2 = (float)jarg2;
30432   {
30433     try {
30434       (arg1)->SetY(arg2);
30435     } catch (std::out_of_range& e) {
30436       {
30437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (std::exception& e) {
30440       {
30441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (...) {
30444       {
30445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30446       };
30447     }
30448   }
30449 }
30450
30451
30452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30454   float arg2 ;
30455
30456   arg1 = (Dali::Actor *)jarg1;
30457   arg2 = (float)jarg2;
30458   {
30459     try {
30460       (arg1)->SetZ(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (...) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30472       };
30473     }
30474   }
30475 }
30476
30477
30478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30480   Dali::Vector3 *arg2 = 0 ;
30481
30482   arg1 = (Dali::Actor *)jarg1;
30483   arg2 = (Dali::Vector3 *)jarg2;
30484   if (!arg2) {
30485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30486     return ;
30487   }
30488   {
30489     try {
30490       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30491     } catch (std::out_of_range& e) {
30492       {
30493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30494       };
30495     } catch (std::exception& e) {
30496       {
30497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30498       };
30499     } catch (...) {
30500       {
30501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30502       };
30503     }
30504   }
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30509   void * jresult ;
30510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30511   Dali::Vector3 result;
30512
30513   arg1 = (Dali::Actor *)jarg1;
30514   {
30515     try {
30516       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30517     } catch (std::out_of_range& e) {
30518       {
30519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30520       };
30521     } catch (std::exception& e) {
30522       {
30523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30524       };
30525     } catch (...) {
30526       {
30527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30528       };
30529     }
30530   }
30531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30537   void * jresult ;
30538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30539   Dali::Vector3 result;
30540
30541   arg1 = (Dali::Actor *)jarg1;
30542   {
30543     try {
30544       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30545     } catch (std::out_of_range& e) {
30546       {
30547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30548       };
30549     } catch (std::exception& e) {
30550       {
30551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30552       };
30553     } catch (...) {
30554       {
30555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30556       };
30557     }
30558   }
30559   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30560   return jresult;
30561 }
30562
30563
30564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30566   bool arg2 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = jarg2 ? true : false;
30570   {
30571     try {
30572       (arg1)->SetInheritPosition(arg2);
30573     } catch (std::out_of_range& e) {
30574       {
30575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30576       };
30577     } catch (std::exception& e) {
30578       {
30579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30584       };
30585     }
30586   }
30587 }
30588
30589
30590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30591   int jresult ;
30592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30593   Dali::PositionInheritanceMode result;
30594
30595   arg1 = (Dali::Actor *)jarg1;
30596   {
30597     try {
30598       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30610       };
30611     }
30612   }
30613   jresult = (int)result;
30614   return jresult;
30615 }
30616
30617
30618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30619   unsigned int jresult ;
30620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30621   bool result;
30622
30623   arg1 = (Dali::Actor *)jarg1;
30624   {
30625     try {
30626       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30627     } catch (std::out_of_range& e) {
30628       {
30629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30630       };
30631     } catch (std::exception& e) {
30632       {
30633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30634       };
30635     } catch (...) {
30636       {
30637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30638       };
30639     }
30640   }
30641   jresult = result;
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30648   Dali::Degree *arg2 = 0 ;
30649   Dali::Vector3 *arg3 = 0 ;
30650
30651   arg1 = (Dali::Actor *)jarg1;
30652   arg2 = (Dali::Degree *)jarg2;
30653   if (!arg2) {
30654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30655     return ;
30656   }
30657   arg3 = (Dali::Vector3 *)jarg3;
30658   if (!arg3) {
30659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30660     return ;
30661   }
30662   {
30663     try {
30664       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30665     } catch (std::out_of_range& e) {
30666       {
30667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30668       };
30669     } catch (std::exception& e) {
30670       {
30671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30676       };
30677     }
30678   }
30679 }
30680
30681
30682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30684   Dali::Radian *arg2 = 0 ;
30685   Dali::Vector3 *arg3 = 0 ;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   arg2 = (Dali::Radian *)jarg2;
30689   if (!arg2) {
30690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30691     return ;
30692   }
30693   arg3 = (Dali::Vector3 *)jarg3;
30694   if (!arg3) {
30695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30696     return ;
30697   }
30698   {
30699     try {
30700       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30701     } catch (std::out_of_range& e) {
30702       {
30703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30704       };
30705     } catch (std::exception& e) {
30706       {
30707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30712       };
30713     }
30714   }
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30720   Dali::Quaternion *arg2 = 0 ;
30721
30722   arg1 = (Dali::Actor *)jarg1;
30723   arg2 = (Dali::Quaternion *)jarg2;
30724   if (!arg2) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30726     return ;
30727   }
30728   {
30729     try {
30730       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745 }
30746
30747
30748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30750   Dali::Degree *arg2 = 0 ;
30751   Dali::Vector3 *arg3 = 0 ;
30752
30753   arg1 = (Dali::Actor *)jarg1;
30754   arg2 = (Dali::Degree *)jarg2;
30755   if (!arg2) {
30756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30757     return ;
30758   }
30759   arg3 = (Dali::Vector3 *)jarg3;
30760   if (!arg3) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30762     return ;
30763   }
30764   {
30765     try {
30766       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30774       };
30775     } catch (...) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30778       };
30779     }
30780   }
30781 }
30782
30783
30784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30786   Dali::Radian *arg2 = 0 ;
30787   Dali::Vector3 *arg3 = 0 ;
30788
30789   arg1 = (Dali::Actor *)jarg1;
30790   arg2 = (Dali::Radian *)jarg2;
30791   if (!arg2) {
30792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30793     return ;
30794   }
30795   arg3 = (Dali::Vector3 *)jarg3;
30796   if (!arg3) {
30797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30798     return ;
30799   }
30800   {
30801     try {
30802       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30814       };
30815     }
30816   }
30817 }
30818
30819
30820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30822   Dali::Quaternion *arg2 = 0 ;
30823
30824   arg1 = (Dali::Actor *)jarg1;
30825   arg2 = (Dali::Quaternion *)jarg2;
30826   if (!arg2) {
30827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30828     return ;
30829   }
30830   {
30831     try {
30832       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30840       };
30841     } catch (...) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30844       };
30845     }
30846   }
30847 }
30848
30849
30850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30851   void * jresult ;
30852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30853   Dali::Quaternion result;
30854
30855   arg1 = (Dali::Actor *)jarg1;
30856   {
30857     try {
30858       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30859     } catch (std::out_of_range& e) {
30860       {
30861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (std::exception& e) {
30864       {
30865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30866       };
30867     } catch (...) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30870       };
30871     }
30872   }
30873   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30880   bool arg2 ;
30881
30882   arg1 = (Dali::Actor *)jarg1;
30883   arg2 = jarg2 ? true : false;
30884   {
30885     try {
30886       (arg1)->SetInheritOrientation(arg2);
30887     } catch (std::out_of_range& e) {
30888       {
30889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30890       };
30891     } catch (std::exception& e) {
30892       {
30893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30894       };
30895     } catch (...) {
30896       {
30897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30898       };
30899     }
30900   }
30901 }
30902
30903
30904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30905   unsigned int jresult ;
30906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30907   bool result;
30908
30909   arg1 = (Dali::Actor *)jarg1;
30910   {
30911     try {
30912       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30913     } catch (std::out_of_range& e) {
30914       {
30915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (std::exception& e) {
30918       {
30919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927   jresult = result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30933   void * jresult ;
30934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30935   Dali::Quaternion result;
30936
30937   arg1 = (Dali::Actor *)jarg1;
30938   {
30939     try {
30940       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (...) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30952       };
30953     }
30954   }
30955   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30956   return jresult;
30957 }
30958
30959
30960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30962   float arg2 ;
30963
30964   arg1 = (Dali::Actor *)jarg1;
30965   arg2 = (float)jarg2;
30966   {
30967     try {
30968       (arg1)->SetScale(arg2);
30969     } catch (std::out_of_range& e) {
30970       {
30971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30972       };
30973     } catch (std::exception& e) {
30974       {
30975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30976       };
30977     } catch (...) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30980       };
30981     }
30982   }
30983 }
30984
30985
30986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30988   float arg2 ;
30989   float arg3 ;
30990   float arg4 ;
30991
30992   arg1 = (Dali::Actor *)jarg1;
30993   arg2 = (float)jarg2;
30994   arg3 = (float)jarg3;
30995   arg4 = (float)jarg4;
30996   {
30997     try {
30998       (arg1)->SetScale(arg2,arg3,arg4);
30999     } catch (std::out_of_range& e) {
31000       {
31001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31002       };
31003     } catch (std::exception& e) {
31004       {
31005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31006       };
31007     } catch (...) {
31008       {
31009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31010       };
31011     }
31012   }
31013 }
31014
31015
31016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31018   Dali::Vector3 *arg2 = 0 ;
31019
31020   arg1 = (Dali::Actor *)jarg1;
31021   arg2 = (Dali::Vector3 *)jarg2;
31022   if (!arg2) {
31023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31024     return ;
31025   }
31026   {
31027     try {
31028       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31036       };
31037     } catch (...) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31040       };
31041     }
31042   }
31043 }
31044
31045
31046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31048   Dali::Vector3 *arg2 = 0 ;
31049
31050   arg1 = (Dali::Actor *)jarg1;
31051   arg2 = (Dali::Vector3 *)jarg2;
31052   if (!arg2) {
31053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31054     return ;
31055   }
31056   {
31057     try {
31058       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31059     } catch (std::out_of_range& e) {
31060       {
31061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31062       };
31063     } catch (std::exception& e) {
31064       {
31065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31070       };
31071     }
31072   }
31073 }
31074
31075
31076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31077   void * jresult ;
31078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31079   Dali::Vector3 result;
31080
31081   arg1 = (Dali::Actor *)jarg1;
31082   {
31083     try {
31084       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31085     } catch (std::out_of_range& e) {
31086       {
31087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31088       };
31089     } catch (std::exception& e) {
31090       {
31091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31092       };
31093     } catch (...) {
31094       {
31095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31096       };
31097     }
31098   }
31099   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31100   return jresult;
31101 }
31102
31103
31104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31105   void * jresult ;
31106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31107   Dali::Vector3 result;
31108
31109   arg1 = (Dali::Actor *)jarg1;
31110   {
31111     try {
31112       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (...) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31124       };
31125     }
31126   }
31127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31134   bool arg2 ;
31135
31136   arg1 = (Dali::Actor *)jarg1;
31137   arg2 = jarg2 ? true : false;
31138   {
31139     try {
31140       (arg1)->SetInheritScale(arg2);
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (...) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31152       };
31153     }
31154   }
31155 }
31156
31157
31158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31159   unsigned int jresult ;
31160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31161   bool result;
31162
31163   arg1 = (Dali::Actor *)jarg1;
31164   {
31165     try {
31166       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31174       };
31175     } catch (...) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31178       };
31179     }
31180   }
31181   jresult = result;
31182   return jresult;
31183 }
31184
31185
31186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31187   void * jresult ;
31188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31189   Dali::Matrix result;
31190
31191   arg1 = (Dali::Actor *)jarg1;
31192   {
31193     try {
31194       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31202       };
31203     } catch (...) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31206       };
31207     }
31208   }
31209   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31210   return jresult;
31211 }
31212
31213
31214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31216   bool arg2 ;
31217
31218   arg1 = (Dali::Actor *)jarg1;
31219   arg2 = jarg2 ? true : false;
31220   {
31221     try {
31222       (arg1)->SetVisible(arg2);
31223     } catch (std::out_of_range& e) {
31224       {
31225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31226       };
31227     } catch (std::exception& e) {
31228       {
31229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31230       };
31231     } catch (...) {
31232       {
31233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31234       };
31235     }
31236   }
31237 }
31238
31239
31240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31241   unsigned int jresult ;
31242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31243   bool result;
31244
31245   arg1 = (Dali::Actor *)jarg1;
31246   {
31247     try {
31248       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31249     } catch (std::out_of_range& e) {
31250       {
31251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31252       };
31253     } catch (std::exception& e) {
31254       {
31255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31256       };
31257     } catch (...) {
31258       {
31259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31260       };
31261     }
31262   }
31263   jresult = result;
31264   return jresult;
31265 }
31266
31267
31268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31270   float arg2 ;
31271
31272   arg1 = (Dali::Actor *)jarg1;
31273   arg2 = (float)jarg2;
31274   {
31275     try {
31276       (arg1)->SetOpacity(arg2);
31277     } catch (std::out_of_range& e) {
31278       {
31279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31280       };
31281     } catch (std::exception& e) {
31282       {
31283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31284       };
31285     } catch (...) {
31286       {
31287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31288       };
31289     }
31290   }
31291 }
31292
31293
31294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31295   float jresult ;
31296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31297   float result;
31298
31299   arg1 = (Dali::Actor *)jarg1;
31300   {
31301     try {
31302       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31303     } catch (std::out_of_range& e) {
31304       {
31305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31306       };
31307     } catch (std::exception& e) {
31308       {
31309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31310       };
31311     } catch (...) {
31312       {
31313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31314       };
31315     }
31316   }
31317   jresult = result;
31318   return jresult;
31319 }
31320
31321
31322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31324   Dali::Vector4 *arg2 = 0 ;
31325
31326   arg1 = (Dali::Actor *)jarg1;
31327   arg2 = (Dali::Vector4 *)jarg2;
31328   if (!arg2) {
31329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31330     return ;
31331   }
31332   {
31333     try {
31334       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31335     } catch (std::out_of_range& e) {
31336       {
31337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31338       };
31339     } catch (std::exception& e) {
31340       {
31341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31342       };
31343     } catch (...) {
31344       {
31345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31346       };
31347     }
31348   }
31349 }
31350
31351
31352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31353   void * jresult ;
31354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31355   Dali::Vector4 result;
31356
31357   arg1 = (Dali::Actor *)jarg1;
31358   {
31359     try {
31360       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31361     } catch (std::out_of_range& e) {
31362       {
31363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31364       };
31365     } catch (std::exception& e) {
31366       {
31367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (...) {
31370       {
31371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31372       };
31373     }
31374   }
31375   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31376   return jresult;
31377 }
31378
31379
31380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31382   Dali::ColorMode arg2 ;
31383
31384   arg1 = (Dali::Actor *)jarg1;
31385   arg2 = (Dali::ColorMode)jarg2;
31386   {
31387     try {
31388       (arg1)->SetColorMode(arg2);
31389     } catch (std::out_of_range& e) {
31390       {
31391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31392       };
31393     } catch (std::exception& e) {
31394       {
31395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31396       };
31397     } catch (...) {
31398       {
31399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31400       };
31401     }
31402   }
31403 }
31404
31405
31406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31407   int jresult ;
31408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31409   Dali::ColorMode result;
31410
31411   arg1 = (Dali::Actor *)jarg1;
31412   {
31413     try {
31414       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31415     } catch (std::out_of_range& e) {
31416       {
31417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31418       };
31419     } catch (std::exception& e) {
31420       {
31421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31422       };
31423     } catch (...) {
31424       {
31425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31426       };
31427     }
31428   }
31429   jresult = (int)result;
31430   return jresult;
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31435   void * jresult ;
31436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31437   Dali::Vector4 result;
31438
31439   arg1 = (Dali::Actor *)jarg1;
31440   {
31441     try {
31442       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31443     } catch (std::out_of_range& e) {
31444       {
31445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31446       };
31447     } catch (std::exception& e) {
31448       {
31449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (...) {
31452       {
31453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31454       };
31455     }
31456   }
31457   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31464   Dali::DrawMode::Type arg2 ;
31465
31466   arg1 = (Dali::Actor *)jarg1;
31467   arg2 = (Dali::DrawMode::Type)jarg2;
31468   {
31469     try {
31470       (arg1)->SetDrawMode(arg2);
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31482       };
31483     }
31484   }
31485 }
31486
31487
31488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31489   int jresult ;
31490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31491   Dali::DrawMode::Type result;
31492
31493   arg1 = (Dali::Actor *)jarg1;
31494   {
31495     try {
31496       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31497     } catch (std::out_of_range& e) {
31498       {
31499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (std::exception& e) {
31502       {
31503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511   jresult = (int)result;
31512   return jresult;
31513 }
31514
31515
31516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31518   bool arg2 ;
31519
31520   arg1 = (Dali::Actor *)jarg1;
31521   arg2 = jarg2 ? true : false;
31522   {
31523     try {
31524       (arg1)->SetSensitive(arg2);
31525     } catch (std::out_of_range& e) {
31526       {
31527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31528       };
31529     } catch (std::exception& e) {
31530       {
31531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31536       };
31537     }
31538   }
31539 }
31540
31541
31542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31543   unsigned int jresult ;
31544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31545   bool result;
31546
31547   arg1 = (Dali::Actor *)jarg1;
31548   {
31549     try {
31550       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (...) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31562       };
31563     }
31564   }
31565   jresult = result;
31566   return jresult;
31567 }
31568
31569
31570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31571   unsigned int jresult ;
31572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31573   float *arg2 = 0 ;
31574   float *arg3 = 0 ;
31575   float arg4 ;
31576   float arg5 ;
31577   bool result;
31578
31579   arg1 = (Dali::Actor *)jarg1;
31580   arg2 = (float *)jarg2;
31581   arg3 = (float *)jarg3;
31582   arg4 = (float)jarg4;
31583   arg5 = (float)jarg5;
31584   {
31585     try {
31586       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31587     } catch (std::out_of_range& e) {
31588       {
31589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31590       };
31591     } catch (std::exception& e) {
31592       {
31593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31594       };
31595     } catch (...) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31598       };
31599     }
31600   }
31601   jresult = result;
31602   return jresult;
31603 }
31604
31605
31606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31608   bool arg2 ;
31609
31610   arg1 = (Dali::Actor *)jarg1;
31611   arg2 = jarg2 ? true : false;
31612   {
31613     try {
31614       (arg1)->SetLeaveRequired(arg2);
31615     } catch (std::out_of_range& e) {
31616       {
31617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31618       };
31619     } catch (std::exception& e) {
31620       {
31621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31622       };
31623     } catch (...) {
31624       {
31625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31626       };
31627     }
31628   }
31629 }
31630
31631
31632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31633   unsigned int jresult ;
31634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31635   bool result;
31636
31637   arg1 = (Dali::Actor *)jarg1;
31638   {
31639     try {
31640       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (...) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31652       };
31653     }
31654   }
31655   jresult = result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31662   bool arg2 ;
31663
31664   arg1 = (Dali::Actor *)jarg1;
31665   arg2 = jarg2 ? true : false;
31666   {
31667     try {
31668       (arg1)->SetKeyboardFocusable(arg2);
31669     } catch (std::out_of_range& e) {
31670       {
31671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31672       };
31673     } catch (std::exception& e) {
31674       {
31675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31680       };
31681     }
31682   }
31683 }
31684
31685
31686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31687   unsigned int jresult ;
31688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31689   bool result;
31690
31691   arg1 = (Dali::Actor *)jarg1;
31692   {
31693     try {
31694       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31695     } catch (std::out_of_range& e) {
31696       {
31697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (std::exception& e) {
31700       {
31701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709   jresult = result;
31710   return jresult;
31711 }
31712
31713
31714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31716   Dali::ResizePolicy::Type arg2 ;
31717   Dali::Dimension::Type arg3 ;
31718
31719   arg1 = (Dali::Actor *)jarg1;
31720   arg2 = (Dali::ResizePolicy::Type)jarg2;
31721   arg3 = (Dali::Dimension::Type)jarg3;
31722   {
31723     try {
31724       (arg1)->SetResizePolicy(arg2,arg3);
31725     } catch (std::out_of_range& e) {
31726       {
31727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31728       };
31729     } catch (std::exception& e) {
31730       {
31731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31736       };
31737     }
31738   }
31739 }
31740
31741
31742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31743   int jresult ;
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Dimension::Type arg2 ;
31746   Dali::ResizePolicy::Type result;
31747
31748   arg1 = (Dali::Actor *)jarg1;
31749   arg2 = (Dali::Dimension::Type)jarg2;
31750   {
31751     try {
31752       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31753     } catch (std::out_of_range& e) {
31754       {
31755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31756       };
31757     } catch (std::exception& e) {
31758       {
31759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (...) {
31762       {
31763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31764       };
31765     }
31766   }
31767   jresult = (int)result;
31768   return jresult;
31769 }
31770
31771
31772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31774   Dali::SizeScalePolicy::Type arg2 ;
31775
31776   arg1 = (Dali::Actor *)jarg1;
31777   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31778   {
31779     try {
31780       (arg1)->SetSizeScalePolicy(arg2);
31781     } catch (std::out_of_range& e) {
31782       {
31783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31784       };
31785     } catch (std::exception& e) {
31786       {
31787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31788       };
31789     } catch (...) {
31790       {
31791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31792       };
31793     }
31794   }
31795 }
31796
31797
31798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31799   int jresult ;
31800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31801   Dali::SizeScalePolicy::Type result;
31802
31803   arg1 = (Dali::Actor *)jarg1;
31804   {
31805     try {
31806       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31807     } catch (std::out_of_range& e) {
31808       {
31809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (std::exception& e) {
31812       {
31813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821   jresult = (int)result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31828   Dali::Vector3 *arg2 = 0 ;
31829
31830   arg1 = (Dali::Actor *)jarg1;
31831   arg2 = (Dali::Vector3 *)jarg2;
31832   if (!arg2) {
31833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31834     return ;
31835   }
31836   {
31837     try {
31838       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31839     } catch (std::out_of_range& e) {
31840       {
31841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31842       };
31843     } catch (std::exception& e) {
31844       {
31845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31850       };
31851     }
31852   }
31853 }
31854
31855
31856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31857   void * jresult ;
31858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31859   Dali::Vector3 result;
31860
31861   arg1 = (Dali::Actor *)jarg1;
31862   {
31863     try {
31864       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (...) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31876       };
31877     }
31878   }
31879   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31880   return jresult;
31881 }
31882
31883
31884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31885   float jresult ;
31886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31887   float arg2 ;
31888   float result;
31889
31890   arg1 = (Dali::Actor *)jarg1;
31891   arg2 = (float)jarg2;
31892   {
31893     try {
31894       result = (float)(arg1)->GetHeightForWidth(arg2);
31895     } catch (std::out_of_range& e) {
31896       {
31897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (std::exception& e) {
31900       {
31901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31902       };
31903     } catch (...) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31906       };
31907     }
31908   }
31909   jresult = result;
31910   return jresult;
31911 }
31912
31913
31914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31915   float jresult ;
31916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31917   float arg2 ;
31918   float result;
31919
31920   arg1 = (Dali::Actor *)jarg1;
31921   arg2 = (float)jarg2;
31922   {
31923     try {
31924       result = (float)(arg1)->GetWidthForHeight(arg2);
31925     } catch (std::out_of_range& e) {
31926       {
31927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31928       };
31929     } catch (std::exception& e) {
31930       {
31931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31932       };
31933     } catch (...) {
31934       {
31935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31936       };
31937     }
31938   }
31939   jresult = result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31945   float jresult ;
31946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31947   Dali::Dimension::Type arg2 ;
31948   float result;
31949
31950   arg1 = (Dali::Actor *)jarg1;
31951   arg2 = (Dali::Dimension::Type)jarg2;
31952   {
31953     try {
31954       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31955     } catch (std::out_of_range& e) {
31956       {
31957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31958       };
31959     } catch (std::exception& e) {
31960       {
31961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (...) {
31964       {
31965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31966       };
31967     }
31968   }
31969   jresult = result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31976   Dali::Padding *arg2 = 0 ;
31977
31978   arg1 = (Dali::Actor *)jarg1;
31979   arg2 = (Dali::Padding *)jarg2;
31980   if (!arg2) {
31981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31982     return ;
31983   }
31984   {
31985     try {
31986       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31987     } catch (std::out_of_range& e) {
31988       {
31989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31990       };
31991     } catch (std::exception& e) {
31992       {
31993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31994       };
31995     } catch (...) {
31996       {
31997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31998       };
31999     }
32000   }
32001 }
32002
32003
32004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32006   Dali::Padding *arg2 = 0 ;
32007
32008   arg1 = (Dali::Actor *)jarg1;
32009   arg2 = (Dali::Padding *)jarg2;
32010   if (!arg2) {
32011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32012     return ;
32013   }
32014   {
32015     try {
32016       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32017     } catch (std::out_of_range& e) {
32018       {
32019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32020       };
32021     } catch (std::exception& e) {
32022       {
32023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32024       };
32025     } catch (...) {
32026       {
32027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32028       };
32029     }
32030   }
32031 }
32032
32033
32034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32036   Dali::Vector2 *arg2 = 0 ;
32037
32038   arg1 = (Dali::Actor *)jarg1;
32039   arg2 = (Dali::Vector2 *)jarg2;
32040   if (!arg2) {
32041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32042     return ;
32043   }
32044   {
32045     try {
32046       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32047     } catch (std::out_of_range& e) {
32048       {
32049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32050       };
32051     } catch (std::exception& e) {
32052       {
32053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32054       };
32055     } catch (...) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32058       };
32059     }
32060   }
32061 }
32062
32063
32064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32065   void * jresult ;
32066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32067   Dali::Vector2 result;
32068
32069   arg1 = (Dali::Actor *)jarg1;
32070   {
32071     try {
32072       result = (arg1)->GetMinimumSize();
32073     } catch (std::out_of_range& e) {
32074       {
32075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32076       };
32077     } catch (std::exception& e) {
32078       {
32079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32080       };
32081     } catch (...) {
32082       {
32083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32084       };
32085     }
32086   }
32087   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32094   Dali::Vector2 *arg2 = 0 ;
32095
32096   arg1 = (Dali::Actor *)jarg1;
32097   arg2 = (Dali::Vector2 *)jarg2;
32098   if (!arg2) {
32099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32100     return ;
32101   }
32102   {
32103     try {
32104       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32105     } catch (std::out_of_range& e) {
32106       {
32107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32108       };
32109     } catch (std::exception& e) {
32110       {
32111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32112       };
32113     } catch (...) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32116       };
32117     }
32118   }
32119 }
32120
32121
32122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32123   void * jresult ;
32124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32125   Dali::Vector2 result;
32126
32127   arg1 = (Dali::Actor *)jarg1;
32128   {
32129     try {
32130       result = (arg1)->GetMaximumSize();
32131     } catch (std::out_of_range& e) {
32132       {
32133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32134       };
32135     } catch (std::exception& e) {
32136       {
32137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32138       };
32139     } catch (...) {
32140       {
32141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32142       };
32143     }
32144   }
32145   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32146   return jresult;
32147 }
32148
32149
32150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32151   int jresult ;
32152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32153   int result;
32154
32155   arg1 = (Dali::Actor *)jarg1;
32156   {
32157     try {
32158       result = (int)(arg1)->GetHierarchyDepth();
32159     } catch (std::out_of_range& e) {
32160       {
32161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32162       };
32163     } catch (std::exception& e) {
32164       {
32165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32166       };
32167     } catch (...) {
32168       {
32169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32170       };
32171     }
32172   }
32173   jresult = result;
32174   return jresult;
32175 }
32176
32177
32178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32179   unsigned int jresult ;
32180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32181   Dali::Renderer *arg2 = 0 ;
32182   unsigned int result;
32183
32184   arg1 = (Dali::Actor *)jarg1;
32185   arg2 = (Dali::Renderer *)jarg2;
32186   if (!arg2) {
32187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32188     return 0;
32189   }
32190   {
32191     try {
32192       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32193     } catch (std::out_of_range& e) {
32194       {
32195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32196       };
32197     } catch (std::exception& e) {
32198       {
32199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32200       };
32201     } catch (...) {
32202       {
32203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32204       };
32205     }
32206   }
32207   jresult = result;
32208   return jresult;
32209 }
32210
32211
32212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32213   unsigned int jresult ;
32214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32215   unsigned int result;
32216
32217   arg1 = (Dali::Actor *)jarg1;
32218   {
32219     try {
32220       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32221     } catch (std::out_of_range& e) {
32222       {
32223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32224       };
32225     } catch (std::exception& e) {
32226       {
32227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32228       };
32229     } catch (...) {
32230       {
32231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32232       };
32233     }
32234   }
32235   jresult = result;
32236   return jresult;
32237 }
32238
32239
32240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32241   void * jresult ;
32242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32243   unsigned int arg2 ;
32244   Dali::Renderer result;
32245
32246   arg1 = (Dali::Actor *)jarg1;
32247   arg2 = (unsigned int)jarg2;
32248   {
32249     try {
32250       result = (arg1)->GetRendererAt(arg2);
32251     } catch (std::out_of_range& e) {
32252       {
32253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (std::exception& e) {
32256       {
32257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32272   Dali::Renderer *arg2 = 0 ;
32273
32274   arg1 = (Dali::Actor *)jarg1;
32275   arg2 = (Dali::Renderer *)jarg2;
32276   if (!arg2) {
32277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32278     return ;
32279   }
32280   {
32281     try {
32282       (arg1)->RemoveRenderer(*arg2);
32283     } catch (std::out_of_range& e) {
32284       {
32285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32286       };
32287     } catch (std::exception& e) {
32288       {
32289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32294       };
32295     }
32296   }
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32302   unsigned int arg2 ;
32303
32304   arg1 = (Dali::Actor *)jarg1;
32305   arg2 = (unsigned int)jarg2;
32306   {
32307     try {
32308       (arg1)->RemoveRenderer(arg2);
32309     } catch (std::out_of_range& e) {
32310       {
32311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32312       };
32313     } catch (std::exception& e) {
32314       {
32315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32320       };
32321     }
32322   }
32323 }
32324
32325
32326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32327   void * jresult ;
32328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32329   Dali::Actor::TouchSignalType *result = 0 ;
32330
32331   arg1 = (Dali::Actor *)jarg1;
32332   {
32333     try {
32334       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32335     } catch (std::out_of_range& e) {
32336       {
32337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32338       };
32339     } catch (std::exception& e) {
32340       {
32341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32346       };
32347     }
32348   }
32349   jresult = (void *)result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32355   void * jresult ;
32356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32357   Dali::Actor::TouchDataSignalType *result = 0 ;
32358
32359   arg1 = (Dali::Actor *)jarg1;
32360   {
32361     try {
32362       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32363     } catch (std::out_of_range& e) {
32364       {
32365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32366       };
32367     } catch (std::exception& e) {
32368       {
32369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32370       };
32371     } catch (...) {
32372       {
32373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32374       };
32375     }
32376   }
32377   jresult = (void *)result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32383   void * jresult ;
32384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32385   Dali::Actor::HoverSignalType *result = 0 ;
32386
32387   arg1 = (Dali::Actor *)jarg1;
32388   {
32389     try {
32390       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (...) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32402       };
32403     }
32404   }
32405   jresult = (void *)result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32411   void * jresult ;
32412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32413   Dali::Actor::WheelEventSignalType *result = 0 ;
32414
32415   arg1 = (Dali::Actor *)jarg1;
32416   {
32417     try {
32418       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32419     } catch (std::out_of_range& e) {
32420       {
32421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32422       };
32423     } catch (std::exception& e) {
32424       {
32425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32426       };
32427     } catch (...) {
32428       {
32429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32430       };
32431     }
32432   }
32433   jresult = (void *)result;
32434   return jresult;
32435 }
32436
32437
32438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32439   void * jresult ;
32440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32441   Dali::Actor::OnStageSignalType *result = 0 ;
32442
32443   arg1 = (Dali::Actor *)jarg1;
32444   {
32445     try {
32446       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32458       };
32459     }
32460   }
32461   jresult = (void *)result;
32462   return jresult;
32463 }
32464
32465
32466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32467   void * jresult ;
32468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32469   Dali::Actor::OffStageSignalType *result = 0 ;
32470
32471   arg1 = (Dali::Actor *)jarg1;
32472   {
32473     try {
32474       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32475     } catch (std::out_of_range& e) {
32476       {
32477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32478       };
32479     } catch (std::exception& e) {
32480       {
32481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32482       };
32483     } catch (...) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32486       };
32487     }
32488   }
32489   jresult = (void *)result;
32490   return jresult;
32491 }
32492
32493
32494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32495   void * jresult ;
32496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32497   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32498
32499   arg1 = (Dali::Actor *)jarg1;
32500   {
32501     try {
32502       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32503     } catch (std::out_of_range& e) {
32504       {
32505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (std::exception& e) {
32508       {
32509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (...) {
32512       {
32513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32514       };
32515     }
32516   }
32517   jresult = (void *)result;
32518   return jresult;
32519 }
32520
32521
32522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32523   Dali::Actor *arg1 = 0 ;
32524
32525   arg1 = (Dali::Actor *)jarg1;
32526   if (!arg1) {
32527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32528     return ;
32529   }
32530   {
32531     try {
32532       Dali::UnparentAndReset(*arg1);
32533     } catch (std::out_of_range& e) {
32534       {
32535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32536       };
32537     } catch (std::exception& e) {
32538       {
32539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32540       };
32541     } catch (...) {
32542       {
32543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32544       };
32545     }
32546   }
32547 }
32548
32549
32550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32551   int jresult ;
32552   int result;
32553
32554   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32555   jresult = (int)result;
32556   return jresult;
32557 }
32558
32559
32560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32561   int jresult ;
32562   int result;
32563
32564   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32565   jresult = (int)result;
32566   return jresult;
32567 }
32568
32569
32570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32571   int jresult ;
32572   int result;
32573
32574   result = (int)Dali::Layer::Property::BEHAVIOR;
32575   jresult = (int)result;
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32581   void * jresult ;
32582   Dali::Layer::Property *result = 0 ;
32583
32584   {
32585     try {
32586       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32587     } catch (std::out_of_range& e) {
32588       {
32589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32590       };
32591     } catch (std::exception& e) {
32592       {
32593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32594       };
32595     } catch (...) {
32596       {
32597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32598       };
32599     }
32600   }
32601   jresult = (void *)result;
32602   return jresult;
32603 }
32604
32605
32606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32607   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32608
32609   arg1 = (Dali::Layer::Property *)jarg1;
32610   {
32611     try {
32612       delete arg1;
32613     } catch (std::out_of_range& e) {
32614       {
32615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32616       };
32617     } catch (std::exception& e) {
32618       {
32619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32624       };
32625     }
32626   }
32627 }
32628
32629
32630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32631   void * jresult ;
32632   Dali::Layer *result = 0 ;
32633
32634   {
32635     try {
32636       result = (Dali::Layer *)new Dali::Layer();
32637     } catch (std::out_of_range& e) {
32638       {
32639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32640       };
32641     } catch (std::exception& e) {
32642       {
32643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32644       };
32645     } catch (...) {
32646       {
32647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32648       };
32649     }
32650   }
32651   jresult = (void *)result;
32652   return jresult;
32653 }
32654
32655
32656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32657   void * jresult ;
32658   Dali::Layer result;
32659
32660   {
32661     try {
32662       result = Dali::Layer::New();
32663     } catch (std::out_of_range& e) {
32664       {
32665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32666       };
32667     } catch (std::exception& e) {
32668       {
32669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32670       };
32671     } catch (...) {
32672       {
32673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32674       };
32675     }
32676   }
32677   jresult = new Dali::Layer((const Dali::Layer &)result);
32678   return jresult;
32679 }
32680
32681
32682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32683   void * jresult ;
32684   Dali::BaseHandle arg1 ;
32685   Dali::BaseHandle *argp1 ;
32686   Dali::Layer result;
32687
32688   argp1 = (Dali::BaseHandle *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32691     return 0;
32692   }
32693   arg1 = *argp1;
32694   {
32695     try {
32696       result = Dali::Layer::DownCast(arg1);
32697     } catch (std::out_of_range& e) {
32698       {
32699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32700       };
32701     } catch (std::exception& e) {
32702       {
32703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32704       };
32705     } catch (...) {
32706       {
32707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32708       };
32709     }
32710   }
32711   jresult = new Dali::Layer((const Dali::Layer &)result);
32712   return jresult;
32713 }
32714
32715
32716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32718
32719   arg1 = (Dali::Layer *)jarg1;
32720   {
32721     try {
32722       delete arg1;
32723     } catch (std::out_of_range& e) {
32724       {
32725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (std::exception& e) {
32728       {
32729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32734       };
32735     }
32736   }
32737 }
32738
32739
32740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32741   void * jresult ;
32742   Dali::Layer *arg1 = 0 ;
32743   Dali::Layer *result = 0 ;
32744
32745   arg1 = (Dali::Layer *)jarg1;
32746   if (!arg1) {
32747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32748     return 0;
32749   }
32750   {
32751     try {
32752       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32760       };
32761     } catch (...) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32764       };
32765     }
32766   }
32767   jresult = (void *)result;
32768   return jresult;
32769 }
32770
32771
32772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32773   void * jresult ;
32774   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32775   Dali::Layer *arg2 = 0 ;
32776   Dali::Layer *result = 0 ;
32777
32778   arg1 = (Dali::Layer *)jarg1;
32779   arg2 = (Dali::Layer *)jarg2;
32780   if (!arg2) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32782     return 0;
32783   }
32784   {
32785     try {
32786       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32787     } catch (std::out_of_range& e) {
32788       {
32789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (std::exception& e) {
32792       {
32793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801   jresult = (void *)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32807   unsigned int jresult ;
32808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32809   unsigned int result;
32810
32811   arg1 = (Dali::Layer *)jarg1;
32812   {
32813     try {
32814       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (...) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32826       };
32827     }
32828   }
32829   jresult = result;
32830   return jresult;
32831 }
32832
32833
32834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32835   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32836
32837   arg1 = (Dali::Layer *)jarg1;
32838   {
32839     try {
32840       (arg1)->Raise();
32841     } catch (std::out_of_range& e) {
32842       {
32843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (std::exception& e) {
32846       {
32847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855 }
32856
32857
32858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32859   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32860
32861   arg1 = (Dali::Layer *)jarg1;
32862   {
32863     try {
32864       (arg1)->Lower();
32865     } catch (std::out_of_range& e) {
32866       {
32867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32868       };
32869     } catch (std::exception& e) {
32870       {
32871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32872       };
32873     } catch (...) {
32874       {
32875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32876       };
32877     }
32878   }
32879 }
32880
32881
32882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32883   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32884   Dali::Layer arg2 ;
32885   Dali::Layer *argp2 ;
32886
32887   arg1 = (Dali::Layer *)jarg1;
32888   argp2 = (Dali::Layer *)jarg2;
32889   if (!argp2) {
32890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32891     return ;
32892   }
32893   arg2 = *argp2;
32894   {
32895     try {
32896       (arg1)->RaiseAbove(arg2);
32897     } catch (std::out_of_range& e) {
32898       {
32899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32900       };
32901     } catch (std::exception& e) {
32902       {
32903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32904       };
32905     } catch (...) {
32906       {
32907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32908       };
32909     }
32910   }
32911 }
32912
32913
32914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32915   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32916   Dali::Layer arg2 ;
32917   Dali::Layer *argp2 ;
32918
32919   arg1 = (Dali::Layer *)jarg1;
32920   argp2 = (Dali::Layer *)jarg2;
32921   if (!argp2) {
32922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32923     return ;
32924   }
32925   arg2 = *argp2;
32926   {
32927     try {
32928       (arg1)->LowerBelow(arg2);
32929     } catch (std::out_of_range& e) {
32930       {
32931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32932       };
32933     } catch (std::exception& e) {
32934       {
32935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32936       };
32937     } catch (...) {
32938       {
32939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32940       };
32941     }
32942   }
32943 }
32944
32945
32946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32947   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32948
32949   arg1 = (Dali::Layer *)jarg1;
32950   {
32951     try {
32952       (arg1)->RaiseToTop();
32953     } catch (std::out_of_range& e) {
32954       {
32955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32956       };
32957     } catch (std::exception& e) {
32958       {
32959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32960       };
32961     } catch (...) {
32962       {
32963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32964       };
32965     }
32966   }
32967 }
32968
32969
32970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32971   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32972
32973   arg1 = (Dali::Layer *)jarg1;
32974   {
32975     try {
32976       (arg1)->LowerToBottom();
32977     } catch (std::out_of_range& e) {
32978       {
32979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32980       };
32981     } catch (std::exception& e) {
32982       {
32983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32984       };
32985     } catch (...) {
32986       {
32987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32988       };
32989     }
32990   }
32991 }
32992
32993
32994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32995   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32996   Dali::Layer arg2 ;
32997   Dali::Layer *argp2 ;
32998
32999   arg1 = (Dali::Layer *)jarg1;
33000   argp2 = (Dali::Layer *)jarg2;
33001   if (!argp2) {
33002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33003     return ;
33004   }
33005   arg2 = *argp2;
33006   {
33007     try {
33008       (arg1)->MoveAbove(arg2);
33009     } catch (std::out_of_range& e) {
33010       {
33011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33012       };
33013     } catch (std::exception& e) {
33014       {
33015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33016       };
33017     } catch (...) {
33018       {
33019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33020       };
33021     }
33022   }
33023 }
33024
33025
33026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33027   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33028   Dali::Layer arg2 ;
33029   Dali::Layer *argp2 ;
33030
33031   arg1 = (Dali::Layer *)jarg1;
33032   argp2 = (Dali::Layer *)jarg2;
33033   if (!argp2) {
33034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33035     return ;
33036   }
33037   arg2 = *argp2;
33038   {
33039     try {
33040       (arg1)->MoveBelow(arg2);
33041     } catch (std::out_of_range& e) {
33042       {
33043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33044       };
33045     } catch (std::exception& e) {
33046       {
33047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33048       };
33049     } catch (...) {
33050       {
33051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33052       };
33053     }
33054   }
33055 }
33056
33057
33058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33059   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33060   Dali::Layer::Behavior arg2 ;
33061
33062   arg1 = (Dali::Layer *)jarg1;
33063   arg2 = (Dali::Layer::Behavior)jarg2;
33064   {
33065     try {
33066       (arg1)->SetBehavior(arg2);
33067     } catch (std::out_of_range& e) {
33068       {
33069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33070       };
33071     } catch (std::exception& e) {
33072       {
33073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33074       };
33075     } catch (...) {
33076       {
33077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33078       };
33079     }
33080   }
33081 }
33082
33083
33084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33085   int jresult ;
33086   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33087   Dali::Layer::Behavior result;
33088
33089   arg1 = (Dali::Layer *)jarg1;
33090   {
33091     try {
33092       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33093     } catch (std::out_of_range& e) {
33094       {
33095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33096       };
33097     } catch (std::exception& e) {
33098       {
33099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33100       };
33101     } catch (...) {
33102       {
33103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33104       };
33105     }
33106   }
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33113   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33114   bool arg2 ;
33115
33116   arg1 = (Dali::Layer *)jarg1;
33117   arg2 = jarg2 ? true : false;
33118   {
33119     try {
33120       (arg1)->SetClipping(arg2);
33121     } catch (std::out_of_range& e) {
33122       {
33123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33124       };
33125     } catch (std::exception& e) {
33126       {
33127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33128       };
33129     } catch (...) {
33130       {
33131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33132       };
33133     }
33134   }
33135 }
33136
33137
33138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33139   unsigned int jresult ;
33140   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33141   bool result;
33142
33143   arg1 = (Dali::Layer *)jarg1;
33144   {
33145     try {
33146       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33147     } catch (std::out_of_range& e) {
33148       {
33149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33150       };
33151     } catch (std::exception& e) {
33152       {
33153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33154       };
33155     } catch (...) {
33156       {
33157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33158       };
33159     }
33160   }
33161   jresult = result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33167   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33168   int arg2 ;
33169   int arg3 ;
33170   int arg4 ;
33171   int arg5 ;
33172
33173   arg1 = (Dali::Layer *)jarg1;
33174   arg2 = (int)jarg2;
33175   arg3 = (int)jarg3;
33176   arg4 = (int)jarg4;
33177   arg5 = (int)jarg5;
33178   {
33179     try {
33180       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33181     } catch (std::out_of_range& e) {
33182       {
33183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33184       };
33185     } catch (std::exception& e) {
33186       {
33187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33188       };
33189     } catch (...) {
33190       {
33191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33192       };
33193     }
33194   }
33195 }
33196
33197
33198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33199   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33200   Dali::ClippingBox arg2 ;
33201   Dali::ClippingBox *argp2 ;
33202
33203   arg1 = (Dali::Layer *)jarg1;
33204   argp2 = (Dali::ClippingBox *)jarg2;
33205   if (!argp2) {
33206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33207     return ;
33208   }
33209   arg2 = *argp2;
33210   {
33211     try {
33212       (arg1)->SetClippingBox(arg2);
33213     } catch (std::out_of_range& e) {
33214       {
33215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33216       };
33217     } catch (std::exception& e) {
33218       {
33219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33220       };
33221     } catch (...) {
33222       {
33223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33224       };
33225     }
33226   }
33227 }
33228
33229
33230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33231   void * jresult ;
33232   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33233   Dali::ClippingBox result;
33234
33235   arg1 = (Dali::Layer *)jarg1;
33236   {
33237     try {
33238       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33239     } catch (std::out_of_range& e) {
33240       {
33241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33242       };
33243     } catch (std::exception& e) {
33244       {
33245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33246       };
33247     } catch (...) {
33248       {
33249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33250       };
33251     }
33252   }
33253   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33259   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33260   bool arg2 ;
33261
33262   arg1 = (Dali::Layer *)jarg1;
33263   arg2 = jarg2 ? true : false;
33264   {
33265     try {
33266       (arg1)->SetDepthTestDisabled(arg2);
33267     } catch (std::out_of_range& e) {
33268       {
33269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33270       };
33271     } catch (std::exception& e) {
33272       {
33273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33274       };
33275     } catch (...) {
33276       {
33277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33278       };
33279     }
33280   }
33281 }
33282
33283
33284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33285   unsigned int jresult ;
33286   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33287   bool result;
33288
33289   arg1 = (Dali::Layer *)jarg1;
33290   {
33291     try {
33292       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33293     } catch (std::out_of_range& e) {
33294       {
33295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (std::exception& e) {
33298       {
33299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33300       };
33301     } catch (...) {
33302       {
33303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33304       };
33305     }
33306   }
33307   jresult = result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33313   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33314   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33315
33316   arg1 = (Dali::Layer *)jarg1;
33317   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33318   {
33319     try {
33320       (arg1)->SetSortFunction(arg2);
33321     } catch (std::out_of_range& e) {
33322       {
33323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33324       };
33325     } catch (std::exception& e) {
33326       {
33327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33328       };
33329     } catch (...) {
33330       {
33331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33332       };
33333     }
33334   }
33335 }
33336
33337
33338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33339   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33340   bool arg2 ;
33341
33342   arg1 = (Dali::Layer *)jarg1;
33343   arg2 = jarg2 ? true : false;
33344   {
33345     try {
33346       (arg1)->SetTouchConsumed(arg2);
33347     } catch (std::out_of_range& e) {
33348       {
33349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33350       };
33351     } catch (std::exception& e) {
33352       {
33353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33354       };
33355     } catch (...) {
33356       {
33357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33358       };
33359     }
33360   }
33361 }
33362
33363
33364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33365   unsigned int jresult ;
33366   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33367   bool result;
33368
33369   arg1 = (Dali::Layer *)jarg1;
33370   {
33371     try {
33372       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33373     } catch (std::out_of_range& e) {
33374       {
33375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (std::exception& e) {
33378       {
33379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387   jresult = result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33393   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33394   bool arg2 ;
33395
33396   arg1 = (Dali::Layer *)jarg1;
33397   arg2 = jarg2 ? true : false;
33398   {
33399     try {
33400       (arg1)->SetHoverConsumed(arg2);
33401     } catch (std::out_of_range& e) {
33402       {
33403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33404       };
33405     } catch (std::exception& e) {
33406       {
33407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33408       };
33409     } catch (...) {
33410       {
33411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33412       };
33413     }
33414   }
33415 }
33416
33417
33418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33419   unsigned int jresult ;
33420   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33421   bool result;
33422
33423   arg1 = (Dali::Layer *)jarg1;
33424   {
33425     try {
33426       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33427     } catch (std::out_of_range& e) {
33428       {
33429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33430       };
33431     } catch (std::exception& e) {
33432       {
33433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (...) {
33436       {
33437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33438       };
33439     }
33440   }
33441   jresult = result;
33442   return jresult;
33443 }
33444
33445
33446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33447   void * jresult ;
33448   Dali::Vector4 *result = 0 ;
33449
33450   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33451   jresult = (void *)result;
33452   return jresult;
33453 }
33454
33455
33456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33457   void * jresult ;
33458   Dali::Vector4 *result = 0 ;
33459
33460   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33461   jresult = (void *)result;
33462   return jresult;
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33467   void * jresult ;
33468   Dali::Stage *result = 0 ;
33469
33470   {
33471     try {
33472       result = (Dali::Stage *)new Dali::Stage();
33473     } catch (std::out_of_range& e) {
33474       {
33475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (std::exception& e) {
33478       {
33479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33493   void * jresult ;
33494   Dali::Stage result;
33495
33496   {
33497     try {
33498       result = Dali::Stage::GetCurrent();
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (...) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33510       };
33511     }
33512   }
33513   jresult = new Dali::Stage((const Dali::Stage &)result);
33514   return jresult;
33515 }
33516
33517
33518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33519   unsigned int jresult ;
33520   bool result;
33521
33522   {
33523     try {
33524       result = (bool)Dali::Stage::IsInstalled();
33525     } catch (std::out_of_range& e) {
33526       {
33527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33528       };
33529     } catch (std::exception& e) {
33530       {
33531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33532       };
33533     } catch (...) {
33534       {
33535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33536       };
33537     }
33538   }
33539   jresult = result;
33540   return jresult;
33541 }
33542
33543
33544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33545   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33546
33547   arg1 = (Dali::Stage *)jarg1;
33548   {
33549     try {
33550       delete arg1;
33551     } catch (std::out_of_range& e) {
33552       {
33553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (std::exception& e) {
33556       {
33557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33562       };
33563     }
33564   }
33565 }
33566
33567
33568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33569   void * jresult ;
33570   Dali::Stage *arg1 = 0 ;
33571   Dali::Stage *result = 0 ;
33572
33573   arg1 = (Dali::Stage *)jarg1;
33574   if (!arg1) {
33575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33576     return 0;
33577   }
33578   {
33579     try {
33580       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33581     } catch (std::out_of_range& e) {
33582       {
33583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (std::exception& e) {
33586       {
33587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595   jresult = (void *)result;
33596   return jresult;
33597 }
33598
33599
33600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33601   void * jresult ;
33602   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33603   Dali::Stage *arg2 = 0 ;
33604   Dali::Stage *result = 0 ;
33605
33606   arg1 = (Dali::Stage *)jarg1;
33607   arg2 = (Dali::Stage *)jarg2;
33608   if (!arg2) {
33609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33610     return 0;
33611   }
33612   {
33613     try {
33614       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33615     } catch (std::out_of_range& e) {
33616       {
33617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (std::exception& e) {
33620       {
33621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629   jresult = (void *)result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33636   Dali::Actor *arg2 = 0 ;
33637
33638   arg1 = (Dali::Stage *)jarg1;
33639   arg2 = (Dali::Actor *)jarg2;
33640   if (!arg2) {
33641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33642     return ;
33643   }
33644   {
33645     try {
33646       (arg1)->Add(*arg2);
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33658       };
33659     }
33660   }
33661 }
33662
33663
33664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33665   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33666   Dali::Actor *arg2 = 0 ;
33667
33668   arg1 = (Dali::Stage *)jarg1;
33669   arg2 = (Dali::Actor *)jarg2;
33670   if (!arg2) {
33671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33672     return ;
33673   }
33674   {
33675     try {
33676       (arg1)->Remove(*arg2);
33677     } catch (std::out_of_range& e) {
33678       {
33679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33680       };
33681     } catch (std::exception& e) {
33682       {
33683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33688       };
33689     }
33690   }
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33695   void * jresult ;
33696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33697   Dali::Vector2 result;
33698
33699   arg1 = (Dali::Stage *)jarg1;
33700   {
33701     try {
33702       result = ((Dali::Stage const *)arg1)->GetSize();
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33714       };
33715     }
33716   }
33717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33718   return jresult;
33719 }
33720
33721
33722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33723   void * jresult ;
33724   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33725   Dali::RenderTaskList result;
33726
33727   arg1 = (Dali::Stage *)jarg1;
33728   {
33729     try {
33730       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33731     } catch (std::out_of_range& e) {
33732       {
33733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (std::exception& e) {
33736       {
33737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33742       };
33743     }
33744   }
33745   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33746   return jresult;
33747 }
33748
33749
33750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33751   unsigned int jresult ;
33752   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33753   unsigned int result;
33754
33755   arg1 = (Dali::Stage *)jarg1;
33756   {
33757     try {
33758       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33759     } catch (std::out_of_range& e) {
33760       {
33761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33762       };
33763     } catch (std::exception& e) {
33764       {
33765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33770       };
33771     }
33772   }
33773   jresult = result;
33774   return jresult;
33775 }
33776
33777
33778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33779   void * jresult ;
33780   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33781   unsigned int arg2 ;
33782   Dali::Layer result;
33783
33784   arg1 = (Dali::Stage *)jarg1;
33785   arg2 = (unsigned int)jarg2;
33786   {
33787     try {
33788       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803   jresult = new Dali::Layer((const Dali::Layer &)result);
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33809   void * jresult ;
33810   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33811   Dali::Layer result;
33812
33813   arg1 = (Dali::Stage *)jarg1;
33814   {
33815     try {
33816       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (...) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33828       };
33829     }
33830   }
33831   jresult = new Dali::Layer((const Dali::Layer &)result);
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33838   Dali::Vector4 arg2 ;
33839   Dali::Vector4 *argp2 ;
33840
33841   arg1 = (Dali::Stage *)jarg1;
33842   argp2 = (Dali::Vector4 *)jarg2;
33843   if (!argp2) {
33844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33845     return ;
33846   }
33847   arg2 = *argp2;
33848   {
33849     try {
33850       (arg1)->SetBackgroundColor(arg2);
33851     } catch (std::out_of_range& e) {
33852       {
33853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33854       };
33855     } catch (std::exception& e) {
33856       {
33857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33862       };
33863     }
33864   }
33865 }
33866
33867
33868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33869   void * jresult ;
33870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33871   Dali::Vector4 result;
33872
33873   arg1 = (Dali::Stage *)jarg1;
33874   {
33875     try {
33876       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33888       };
33889     }
33890   }
33891   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33897   void * jresult ;
33898   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33899   Dali::Vector2 result;
33900
33901   arg1 = (Dali::Stage *)jarg1;
33902   {
33903     try {
33904       result = ((Dali::Stage const *)arg1)->GetDpi();
33905     } catch (std::out_of_range& e) {
33906       {
33907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33908       };
33909     } catch (std::exception& e) {
33910       {
33911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33912       };
33913     } catch (...) {
33914       {
33915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33916       };
33917     }
33918   }
33919   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33920   return jresult;
33921 }
33922
33923
33924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33925   void * jresult ;
33926   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33927   Dali::ObjectRegistry result;
33928
33929   arg1 = (Dali::Stage *)jarg1;
33930   {
33931     try {
33932       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33933     } catch (std::out_of_range& e) {
33934       {
33935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33936       };
33937     } catch (std::exception& e) {
33938       {
33939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33940       };
33941     } catch (...) {
33942       {
33943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33944       };
33945     }
33946   }
33947   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33948   return jresult;
33949 }
33950
33951
33952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33953   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33954   float arg2 ;
33955
33956   arg1 = (Dali::Stage *)jarg1;
33957   arg2 = (float)jarg2;
33958   {
33959     try {
33960       (arg1)->KeepRendering(arg2);
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33968       };
33969     } catch (...) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33972       };
33973     }
33974   }
33975 }
33976
33977
33978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33979   void * jresult ;
33980   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33981   Dali::Stage::KeyEventSignalType *result = 0 ;
33982
33983   arg1 = (Dali::Stage *)jarg1;
33984   {
33985     try {
33986       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33987     } catch (std::out_of_range& e) {
33988       {
33989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33990       };
33991     } catch (std::exception& e) {
33992       {
33993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (...) {
33996       {
33997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33998       };
33999     }
34000   }
34001   jresult = (void *)result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34007   void * jresult ;
34008   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34009   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34010
34011   arg1 = (Dali::Stage *)jarg1;
34012   {
34013     try {
34014       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (...) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34026       };
34027     }
34028   }
34029   jresult = (void *)result;
34030   return jresult;
34031 }
34032
34033
34034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34035   void * jresult ;
34036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34037   Dali::Stage::TouchSignalType *result = 0 ;
34038
34039   arg1 = (Dali::Stage *)jarg1;
34040   {
34041     try {
34042       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34043     } catch (std::out_of_range& e) {
34044       {
34045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34046       };
34047     } catch (std::exception& e) {
34048       {
34049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34050       };
34051     } catch (...) {
34052       {
34053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34054       };
34055     }
34056   }
34057   jresult = (void *)result;
34058   return jresult;
34059 }
34060
34061
34062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34063   void * jresult ;
34064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34065   Dali::Stage::WheelEventSignalType *result = 0 ;
34066
34067   arg1 = (Dali::Stage *)jarg1;
34068   {
34069     try {
34070       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34071     } catch (std::out_of_range& e) {
34072       {
34073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (std::exception& e) {
34076       {
34077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085   jresult = (void *)result;
34086   return jresult;
34087 }
34088
34089
34090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34091   void * jresult ;
34092   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34093   Dali::Stage::ContextStatusSignal *result = 0 ;
34094
34095   arg1 = (Dali::Stage *)jarg1;
34096   {
34097     try {
34098       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34110       };
34111     }
34112   }
34113   jresult = (void *)result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34119   void * jresult ;
34120   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34121   Dali::Stage::ContextStatusSignal *result = 0 ;
34122
34123   arg1 = (Dali::Stage *)jarg1;
34124   {
34125     try {
34126       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (...) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34138       };
34139     }
34140   }
34141   jresult = (void *)result;
34142   return jresult;
34143 }
34144
34145
34146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34147   void * jresult ;
34148   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34149   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34150
34151   arg1 = (Dali::Stage *)jarg1;
34152   {
34153     try {
34154       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34155     } catch (std::out_of_range& e) {
34156       {
34157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (std::exception& e) {
34160       {
34161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169   jresult = (void *)result;
34170   return jresult;
34171 }
34172
34173
34174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34175   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34176
34177   arg1 = (Dali::RelayoutContainer *)jarg1;
34178   {
34179     try {
34180       delete arg1;
34181     } catch (std::out_of_range& e) {
34182       {
34183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34184       };
34185     } catch (std::exception& e) {
34186       {
34187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34188       };
34189     } catch (...) {
34190       {
34191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34192       };
34193     }
34194   }
34195 }
34196
34197
34198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34199   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34200   Dali::Actor *arg2 = 0 ;
34201   Dali::Vector2 *arg3 = 0 ;
34202
34203   arg1 = (Dali::RelayoutContainer *)jarg1;
34204   arg2 = (Dali::Actor *)jarg2;
34205   if (!arg2) {
34206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34207     return ;
34208   }
34209   arg3 = (Dali::Vector2 *)jarg3;
34210   if (!arg3) {
34211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34212     return ;
34213   }
34214   {
34215     try {
34216       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34217     } catch (std::out_of_range& e) {
34218       {
34219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34220       };
34221     } catch (std::exception& e) {
34222       {
34223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34224       };
34225     } catch (...) {
34226       {
34227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34228       };
34229     }
34230   }
34231 }
34232
34233
34234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34235   void * jresult ;
34236   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34237   Dali::CustomActor result;
34238
34239   arg1 = (Dali::CustomActorImpl *)jarg1;
34240   {
34241     try {
34242       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34250       };
34251     } catch (...) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34254       };
34255     }
34256   }
34257   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34258   return jresult;
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34263   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34264   int arg2 ;
34265
34266   arg1 = (Dali::CustomActorImpl *)jarg1;
34267   arg2 = (int)jarg2;
34268   {
34269     try {
34270       (arg1)->OnStageConnection(arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285 }
34286
34287
34288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34290
34291   arg1 = (Dali::CustomActorImpl *)jarg1;
34292   {
34293     try {
34294       (arg1)->OnStageDisconnection();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34302       };
34303     } catch (...) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34306       };
34307     }
34308   }
34309 }
34310
34311
34312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34313   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34314   Dali::Actor *arg2 = 0 ;
34315
34316   arg1 = (Dali::CustomActorImpl *)jarg1;
34317   arg2 = (Dali::Actor *)jarg2;
34318   if (!arg2) {
34319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34320     return ;
34321   }
34322   {
34323     try {
34324       (arg1)->OnChildAdd(*arg2);
34325     } catch (std::out_of_range& e) {
34326       {
34327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34328       };
34329     } catch (std::exception& e) {
34330       {
34331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34332       };
34333     } catch (...) {
34334       {
34335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34336       };
34337     }
34338   }
34339 }
34340
34341
34342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34344   Dali::Actor *arg2 = 0 ;
34345
34346   arg1 = (Dali::CustomActorImpl *)jarg1;
34347   arg2 = (Dali::Actor *)jarg2;
34348   if (!arg2) {
34349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34350     return ;
34351   }
34352   {
34353     try {
34354       (arg1)->OnChildRemove(*arg2);
34355     } catch (std::out_of_range& e) {
34356       {
34357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34358       };
34359     } catch (std::exception& e) {
34360       {
34361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34362       };
34363     } catch (...) {
34364       {
34365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34366       };
34367     }
34368   }
34369 }
34370
34371
34372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34374   Dali::Property::Index arg2 ;
34375   Dali::Property::Value arg3 ;
34376   Dali::Property::Value *argp3 ;
34377
34378   arg1 = (Dali::CustomActorImpl *)jarg1;
34379   arg2 = (Dali::Property::Index)jarg2;
34380   argp3 = (Dali::Property::Value *)jarg3;
34381   if (!argp3) {
34382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34383     return ;
34384   }
34385   arg3 = *argp3;
34386   {
34387     try {
34388       (arg1)->OnPropertySet(arg2,arg3);
34389     } catch (std::out_of_range& e) {
34390       {
34391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (std::exception& e) {
34394       {
34395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (...) {
34398       {
34399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34400       };
34401     }
34402   }
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34408   Dali::Vector3 *arg2 = 0 ;
34409
34410   arg1 = (Dali::CustomActorImpl *)jarg1;
34411   arg2 = (Dali::Vector3 *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34414     return ;
34415   }
34416   {
34417     try {
34418       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34426       };
34427     } catch (...) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34430       };
34431     }
34432   }
34433 }
34434
34435
34436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34437   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34438   Dali::Animation *arg2 = 0 ;
34439   Dali::Vector3 *arg3 = 0 ;
34440
34441   arg1 = (Dali::CustomActorImpl *)jarg1;
34442   arg2 = (Dali::Animation *)jarg2;
34443   if (!arg2) {
34444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34445     return ;
34446   }
34447   arg3 = (Dali::Vector3 *)jarg3;
34448   if (!arg3) {
34449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34450     return ;
34451   }
34452   {
34453     try {
34454       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34455     } catch (std::out_of_range& e) {
34456       {
34457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34458       };
34459     } catch (std::exception& e) {
34460       {
34461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34462       };
34463     } catch (...) {
34464       {
34465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34466       };
34467     }
34468   }
34469 }
34470
34471
34472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34473   unsigned int jresult ;
34474   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34475   Dali::TouchEvent *arg2 = 0 ;
34476   bool result;
34477
34478   arg1 = (Dali::CustomActorImpl *)jarg1;
34479   arg2 = (Dali::TouchEvent *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34482     return 0;
34483   }
34484   {
34485     try {
34486       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34507   unsigned int jresult ;
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::HoverEvent *arg2 = 0 ;
34510   bool result;
34511
34512   arg1 = (Dali::CustomActorImpl *)jarg1;
34513   arg2 = (Dali::HoverEvent *)jarg2;
34514   if (!arg2) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34516     return 0;
34517   }
34518   {
34519     try {
34520       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34528       };
34529     } catch (...) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34532       };
34533     }
34534   }
34535   jresult = result;
34536   return jresult;
34537 }
34538
34539
34540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34541   unsigned int jresult ;
34542   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34543   Dali::KeyEvent *arg2 = 0 ;
34544   bool result;
34545
34546   arg1 = (Dali::CustomActorImpl *)jarg1;
34547   arg2 = (Dali::KeyEvent *)jarg2;
34548   if (!arg2) {
34549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34550     return 0;
34551   }
34552   {
34553     try {
34554       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34555     } catch (std::out_of_range& e) {
34556       {
34557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34558       };
34559     } catch (std::exception& e) {
34560       {
34561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34562       };
34563     } catch (...) {
34564       {
34565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34566       };
34567     }
34568   }
34569   jresult = result;
34570   return jresult;
34571 }
34572
34573
34574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34575   unsigned int jresult ;
34576   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34577   Dali::WheelEvent *arg2 = 0 ;
34578   bool result;
34579
34580   arg1 = (Dali::CustomActorImpl *)jarg1;
34581   arg2 = (Dali::WheelEvent *)jarg2;
34582   if (!arg2) {
34583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34584     return 0;
34585   }
34586   {
34587     try {
34588       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34589     } catch (std::out_of_range& e) {
34590       {
34591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34592       };
34593     } catch (std::exception& e) {
34594       {
34595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (...) {
34598       {
34599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34600       };
34601     }
34602   }
34603   jresult = result;
34604   return jresult;
34605 }
34606
34607
34608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34609   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34610   Dali::Vector2 *arg2 = 0 ;
34611   Dali::RelayoutContainer *arg3 = 0 ;
34612
34613   arg1 = (Dali::CustomActorImpl *)jarg1;
34614   arg2 = (Dali::Vector2 *)jarg2;
34615   if (!arg2) {
34616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34617     return ;
34618   }
34619   arg3 = (Dali::RelayoutContainer *)jarg3;
34620   if (!arg3) {
34621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34622     return ;
34623   }
34624   {
34625     try {
34626       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34627     } catch (std::out_of_range& e) {
34628       {
34629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34630       };
34631     } catch (std::exception& e) {
34632       {
34633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34634       };
34635     } catch (...) {
34636       {
34637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34638       };
34639     }
34640   }
34641 }
34642
34643
34644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34646   Dali::ResizePolicy::Type arg2 ;
34647   Dali::Dimension::Type arg3 ;
34648
34649   arg1 = (Dali::CustomActorImpl *)jarg1;
34650   arg2 = (Dali::ResizePolicy::Type)jarg2;
34651   arg3 = (Dali::Dimension::Type)jarg3;
34652   {
34653     try {
34654       (arg1)->OnSetResizePolicy(arg2,arg3);
34655     } catch (std::out_of_range& e) {
34656       {
34657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34658       };
34659     } catch (std::exception& e) {
34660       {
34661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34662       };
34663     } catch (...) {
34664       {
34665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34666       };
34667     }
34668   }
34669 }
34670
34671
34672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34673   void * jresult ;
34674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34675   Dali::Vector3 result;
34676
34677   arg1 = (Dali::CustomActorImpl *)jarg1;
34678   {
34679     try {
34680       result = (arg1)->GetNaturalSize();
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34688       };
34689     } catch (...) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34692       };
34693     }
34694   }
34695   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34696   return jresult;
34697 }
34698
34699
34700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34701   float jresult ;
34702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34703   Dali::Actor *arg2 = 0 ;
34704   Dali::Dimension::Type arg3 ;
34705   float result;
34706
34707   arg1 = (Dali::CustomActorImpl *)jarg1;
34708   arg2 = (Dali::Actor *)jarg2;
34709   if (!arg2) {
34710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34711     return 0;
34712   }
34713   arg3 = (Dali::Dimension::Type)jarg3;
34714   {
34715     try {
34716       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34717     } catch (std::out_of_range& e) {
34718       {
34719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34720       };
34721     } catch (std::exception& e) {
34722       {
34723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34724       };
34725     } catch (...) {
34726       {
34727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34728       };
34729     }
34730   }
34731   jresult = result;
34732   return jresult;
34733 }
34734
34735
34736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34737   float jresult ;
34738   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34739   float arg2 ;
34740   float result;
34741
34742   arg1 = (Dali::CustomActorImpl *)jarg1;
34743   arg2 = (float)jarg2;
34744   {
34745     try {
34746       result = (float)(arg1)->GetHeightForWidth(arg2);
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34758       };
34759     }
34760   }
34761   jresult = result;
34762   return jresult;
34763 }
34764
34765
34766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34767   float jresult ;
34768   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34769   float arg2 ;
34770   float result;
34771
34772   arg1 = (Dali::CustomActorImpl *)jarg1;
34773   arg2 = (float)jarg2;
34774   {
34775     try {
34776       result = (float)(arg1)->GetWidthForHeight(arg2);
34777     } catch (std::out_of_range& e) {
34778       {
34779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34780       };
34781     } catch (std::exception& e) {
34782       {
34783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34784       };
34785     } catch (...) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34788       };
34789     }
34790   }
34791   jresult = result;
34792   return jresult;
34793 }
34794
34795
34796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34797   unsigned int jresult ;
34798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34799   Dali::Dimension::Type arg2 ;
34800   bool result;
34801
34802   arg1 = (Dali::CustomActorImpl *)jarg1;
34803   arg2 = (Dali::Dimension::Type)jarg2;
34804   {
34805     try {
34806       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34818       };
34819     }
34820   }
34821   jresult = result;
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34827   unsigned int jresult ;
34828   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34829   bool result;
34830
34831   arg1 = (Dali::CustomActorImpl *)jarg1;
34832   {
34833     try {
34834       result = (bool)(arg1)->RelayoutDependentOnChildren();
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34842       };
34843     } catch (...) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34846       };
34847     }
34848   }
34849   jresult = result;
34850   return jresult;
34851 }
34852
34853
34854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34856   Dali::Dimension::Type arg2 ;
34857
34858   arg1 = (Dali::CustomActorImpl *)jarg1;
34859   arg2 = (Dali::Dimension::Type)jarg2;
34860   {
34861     try {
34862       (arg1)->OnCalculateRelayoutSize(arg2);
34863     } catch (std::out_of_range& e) {
34864       {
34865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34866       };
34867     } catch (std::exception& e) {
34868       {
34869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34874       };
34875     }
34876   }
34877 }
34878
34879
34880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34882   float arg2 ;
34883   Dali::Dimension::Type arg3 ;
34884
34885   arg1 = (Dali::CustomActorImpl *)jarg1;
34886   arg2 = (float)jarg2;
34887   arg3 = (Dali::Dimension::Type)jarg3;
34888   {
34889     try {
34890       (arg1)->OnLayoutNegotiated(arg2,arg3);
34891     } catch (std::out_of_range& e) {
34892       {
34893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34894       };
34895     } catch (std::exception& e) {
34896       {
34897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34898       };
34899     } catch (...) {
34900       {
34901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34902       };
34903     }
34904   }
34905 }
34906
34907
34908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34909   unsigned int jresult ;
34910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34911   bool result;
34912
34913   arg1 = (Dali::CustomActorImpl *)jarg1;
34914   {
34915     try {
34916       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34917     } catch (std::out_of_range& e) {
34918       {
34919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (std::exception& e) {
34922       {
34923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34924       };
34925     } catch (...) {
34926       {
34927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34928       };
34929     }
34930   }
34931   jresult = result;
34932   return jresult;
34933 }
34934
34935
34936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34937   unsigned int jresult ;
34938   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34939   bool result;
34940
34941   arg1 = (Dali::CustomActorImpl *)jarg1;
34942   {
34943     try {
34944       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34945     } catch (std::out_of_range& e) {
34946       {
34947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34948       };
34949     } catch (std::exception& e) {
34950       {
34951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34952       };
34953     } catch (...) {
34954       {
34955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34956       };
34957     }
34958   }
34959   jresult = result;
34960   return jresult;
34961 }
34962
34963
34964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34965   unsigned int jresult ;
34966   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34967   bool result;
34968
34969   arg1 = (Dali::CustomActorImpl *)jarg1;
34970   {
34971     try {
34972       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34973     } catch (std::out_of_range& e) {
34974       {
34975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34976       };
34977     } catch (std::exception& e) {
34978       {
34979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34980       };
34981     } catch (...) {
34982       {
34983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34984       };
34985     }
34986   }
34987   jresult = result;
34988   return jresult;
34989 }
34990
34991
34992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34993   unsigned int jresult ;
34994   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34995   bool result;
34996
34997   arg1 = (Dali::CustomActorImpl *)jarg1;
34998   {
34999     try {
35000       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
35001     } catch (std::out_of_range& e) {
35002       {
35003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35004       };
35005     } catch (std::exception& e) {
35006       {
35007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35008       };
35009     } catch (...) {
35010       {
35011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35012       };
35013     }
35014   }
35015   jresult = result;
35016   return jresult;
35017 }
35018
35019
35020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35021   void * jresult ;
35022   Dali::CustomActor *result = 0 ;
35023
35024   {
35025     try {
35026       result = (Dali::CustomActor *)new Dali::CustomActor();
35027     } catch (std::out_of_range& e) {
35028       {
35029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (std::exception& e) {
35032       {
35033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041   jresult = (void *)result;
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35047   void * jresult ;
35048   Dali::BaseHandle arg1 ;
35049   Dali::BaseHandle *argp1 ;
35050   Dali::CustomActor result;
35051
35052   argp1 = (Dali::BaseHandle *)jarg1;
35053   if (!argp1) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35055     return 0;
35056   }
35057   arg1 = *argp1;
35058   {
35059     try {
35060       result = Dali::CustomActor::DownCast(arg1);
35061     } catch (std::out_of_range& e) {
35062       {
35063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35064       };
35065     } catch (std::exception& e) {
35066       {
35067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35068       };
35069     } catch (...) {
35070       {
35071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35072       };
35073     }
35074   }
35075   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35081   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35082
35083   arg1 = (Dali::CustomActor *)jarg1;
35084   {
35085     try {
35086       delete arg1;
35087     } catch (std::out_of_range& e) {
35088       {
35089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35090       };
35091     } catch (std::exception& e) {
35092       {
35093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (...) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35098       };
35099     }
35100   }
35101 }
35102
35103
35104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35105   void * jresult ;
35106   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35107   Dali::CustomActorImpl *result = 0 ;
35108
35109   arg1 = (Dali::CustomActor *)jarg1;
35110   {
35111     try {
35112       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35113     } catch (std::out_of_range& e) {
35114       {
35115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (std::exception& e) {
35118       {
35119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35120       };
35121     } catch (...) {
35122       {
35123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35124       };
35125     }
35126   }
35127   jresult = (void *)result;
35128   return jresult;
35129 }
35130
35131
35132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35133   void * jresult ;
35134   Dali::CustomActorImpl *arg1 = 0 ;
35135   Dali::CustomActor *result = 0 ;
35136
35137   arg1 = (Dali::CustomActorImpl *)jarg1;
35138   if (!arg1) {
35139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35140     return 0;
35141   }
35142   {
35143     try {
35144       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35145     } catch (std::out_of_range& e) {
35146       {
35147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35148       };
35149     } catch (std::exception& e) {
35150       {
35151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35156       };
35157     }
35158   }
35159   jresult = (void *)result;
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35165   void * jresult ;
35166   Dali::CustomActor *arg1 = 0 ;
35167   Dali::CustomActor *result = 0 ;
35168
35169   arg1 = (Dali::CustomActor *)jarg1;
35170   if (!arg1) {
35171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35172     return 0;
35173   }
35174   {
35175     try {
35176       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35177     } catch (std::out_of_range& e) {
35178       {
35179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35180       };
35181     } catch (std::exception& e) {
35182       {
35183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35184       };
35185     } catch (...) {
35186       {
35187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35188       };
35189     }
35190   }
35191   jresult = (void *)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35197   void * jresult ;
35198   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35199   Dali::CustomActor *arg2 = 0 ;
35200   Dali::CustomActor *result = 0 ;
35201
35202   arg1 = (Dali::CustomActor *)jarg1;
35203   arg2 = (Dali::CustomActor *)jarg2;
35204   if (!arg2) {
35205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35206     return 0;
35207   }
35208   {
35209     try {
35210       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35211     } catch (std::out_of_range& e) {
35212       {
35213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35214       };
35215     } catch (std::exception& e) {
35216       {
35217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35222       };
35223     }
35224   }
35225   jresult = (void *)result;
35226   return jresult;
35227 }
35228
35229
35230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35231   int jresult ;
35232   int result;
35233
35234   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35235   jresult = (int)result;
35236   return jresult;
35237 }
35238
35239
35240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35241   int jresult ;
35242   int result;
35243
35244   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35245   jresult = (int)result;
35246   return jresult;
35247 }
35248
35249
35250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35251   int jresult ;
35252   int result;
35253
35254   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35255   jresult = (int)result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35261   int jresult ;
35262   int result;
35263
35264   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35265   jresult = (int)result;
35266   return jresult;
35267 }
35268
35269
35270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35271   int jresult ;
35272   int result;
35273
35274   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35275   jresult = (int)result;
35276   return jresult;
35277 }
35278
35279
35280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35281   int jresult ;
35282   int result;
35283
35284   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35285   jresult = (int)result;
35286   return jresult;
35287 }
35288
35289
35290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35291   int jresult ;
35292   int result;
35293
35294   result = (int)Dali::PanGestureDetector::Property::PANNING;
35295   jresult = (int)result;
35296   return jresult;
35297 }
35298
35299
35300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35301   void * jresult ;
35302   Dali::PanGestureDetector::Property *result = 0 ;
35303
35304   {
35305     try {
35306       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35307     } catch (std::out_of_range& e) {
35308       {
35309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (std::exception& e) {
35312       {
35313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35318       };
35319     }
35320   }
35321   jresult = (void *)result;
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35327   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35328
35329   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35330   {
35331     try {
35332       delete arg1;
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (...) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35344       };
35345     }
35346   }
35347 }
35348
35349
35350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35351   void * jresult ;
35352   Dali::Radian *result = 0 ;
35353
35354   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35355   jresult = (void *)result;
35356   return jresult;
35357 }
35358
35359
35360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35361   void * jresult ;
35362   Dali::Radian *result = 0 ;
35363
35364   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35365   jresult = (void *)result;
35366   return jresult;
35367 }
35368
35369
35370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35371   void * jresult ;
35372   Dali::Radian *result = 0 ;
35373
35374   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35375   jresult = (void *)result;
35376   return jresult;
35377 }
35378
35379
35380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35381   void * jresult ;
35382   Dali::Radian *result = 0 ;
35383
35384   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35385   jresult = (void *)result;
35386   return jresult;
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35391   void * jresult ;
35392   Dali::Radian *result = 0 ;
35393
35394   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35395   jresult = (void *)result;
35396   return jresult;
35397 }
35398
35399
35400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35401   void * jresult ;
35402   Dali::Radian *result = 0 ;
35403
35404   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35405   jresult = (void *)result;
35406   return jresult;
35407 }
35408
35409
35410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35411   void * jresult ;
35412   Dali::Radian *result = 0 ;
35413
35414   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35415   jresult = (void *)result;
35416   return jresult;
35417 }
35418
35419
35420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35421   void * jresult ;
35422   Dali::PanGestureDetector *result = 0 ;
35423
35424   {
35425     try {
35426       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35427     } catch (std::out_of_range& e) {
35428       {
35429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35430       };
35431     } catch (std::exception& e) {
35432       {
35433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (...) {
35436       {
35437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35438       };
35439     }
35440   }
35441   jresult = (void *)result;
35442   return jresult;
35443 }
35444
35445
35446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35447   void * jresult ;
35448   Dali::PanGestureDetector result;
35449
35450   {
35451     try {
35452       result = Dali::PanGestureDetector::New();
35453     } catch (std::out_of_range& e) {
35454       {
35455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35456       };
35457     } catch (std::exception& e) {
35458       {
35459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35460       };
35461     } catch (...) {
35462       {
35463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35464       };
35465     }
35466   }
35467   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35468   return jresult;
35469 }
35470
35471
35472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35473   void * jresult ;
35474   Dali::BaseHandle arg1 ;
35475   Dali::BaseHandle *argp1 ;
35476   Dali::PanGestureDetector result;
35477
35478   argp1 = (Dali::BaseHandle *)jarg1;
35479   if (!argp1) {
35480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35481     return 0;
35482   }
35483   arg1 = *argp1;
35484   {
35485     try {
35486       result = Dali::PanGestureDetector::DownCast(arg1);
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35507   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35508
35509   arg1 = (Dali::PanGestureDetector *)jarg1;
35510   {
35511     try {
35512       delete arg1;
35513     } catch (std::out_of_range& e) {
35514       {
35515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35516       };
35517     } catch (std::exception& e) {
35518       {
35519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35520       };
35521     } catch (...) {
35522       {
35523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35524       };
35525     }
35526   }
35527 }
35528
35529
35530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35531   void * jresult ;
35532   Dali::PanGestureDetector *arg1 = 0 ;
35533   Dali::PanGestureDetector *result = 0 ;
35534
35535   arg1 = (Dali::PanGestureDetector *)jarg1;
35536   if (!arg1) {
35537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35538     return 0;
35539   }
35540   {
35541     try {
35542       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35554       };
35555     }
35556   }
35557   jresult = (void *)result;
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35563   void * jresult ;
35564   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35565   Dali::PanGestureDetector *arg2 = 0 ;
35566   Dali::PanGestureDetector *result = 0 ;
35567
35568   arg1 = (Dali::PanGestureDetector *)jarg1;
35569   arg2 = (Dali::PanGestureDetector *)jarg2;
35570   if (!arg2) {
35571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35572     return 0;
35573   }
35574   {
35575     try {
35576       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35577     } catch (std::out_of_range& e) {
35578       {
35579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35580       };
35581     } catch (std::exception& e) {
35582       {
35583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35584       };
35585     } catch (...) {
35586       {
35587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35588       };
35589     }
35590   }
35591   jresult = (void *)result;
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35597   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35598   unsigned int arg2 ;
35599
35600   arg1 = (Dali::PanGestureDetector *)jarg1;
35601   arg2 = (unsigned int)jarg2;
35602   {
35603     try {
35604       (arg1)->SetMinimumTouchesRequired(arg2);
35605     } catch (std::out_of_range& e) {
35606       {
35607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (std::exception& e) {
35610       {
35611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35616       };
35617     }
35618   }
35619 }
35620
35621
35622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35624   unsigned int arg2 ;
35625
35626   arg1 = (Dali::PanGestureDetector *)jarg1;
35627   arg2 = (unsigned int)jarg2;
35628   {
35629     try {
35630       (arg1)->SetMaximumTouchesRequired(arg2);
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35638       };
35639     } catch (...) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35642       };
35643     }
35644   }
35645 }
35646
35647
35648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35649   unsigned int jresult ;
35650   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35651   unsigned int result;
35652
35653   arg1 = (Dali::PanGestureDetector *)jarg1;
35654   {
35655     try {
35656       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (...) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35668       };
35669     }
35670   }
35671   jresult = result;
35672   return jresult;
35673 }
35674
35675
35676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35677   unsigned int jresult ;
35678   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35679   unsigned int result;
35680
35681   arg1 = (Dali::PanGestureDetector *)jarg1;
35682   {
35683     try {
35684       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35685     } catch (std::out_of_range& e) {
35686       {
35687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35688       };
35689     } catch (std::exception& e) {
35690       {
35691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (...) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35696       };
35697     }
35698   }
35699   jresult = result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35705   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35706   Dali::Radian arg2 ;
35707   Dali::Radian arg3 ;
35708   Dali::Radian *argp2 ;
35709   Dali::Radian *argp3 ;
35710
35711   arg1 = (Dali::PanGestureDetector *)jarg1;
35712   argp2 = (Dali::Radian *)jarg2;
35713   if (!argp2) {
35714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35715     return ;
35716   }
35717   arg2 = *argp2;
35718   argp3 = (Dali::Radian *)jarg3;
35719   if (!argp3) {
35720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35721     return ;
35722   }
35723   arg3 = *argp3;
35724   {
35725     try {
35726       (arg1)->AddAngle(arg2,arg3);
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35738       };
35739     }
35740   }
35741 }
35742
35743
35744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35745   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35746   Dali::Radian arg2 ;
35747   Dali::Radian *argp2 ;
35748
35749   arg1 = (Dali::PanGestureDetector *)jarg1;
35750   argp2 = (Dali::Radian *)jarg2;
35751   if (!argp2) {
35752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35753     return ;
35754   }
35755   arg2 = *argp2;
35756   {
35757     try {
35758       (arg1)->AddAngle(arg2);
35759     } catch (std::out_of_range& e) {
35760       {
35761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35762       };
35763     } catch (std::exception& e) {
35764       {
35765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35766       };
35767     } catch (...) {
35768       {
35769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35770       };
35771     }
35772   }
35773 }
35774
35775
35776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35778   Dali::Radian arg2 ;
35779   Dali::Radian arg3 ;
35780   Dali::Radian *argp2 ;
35781   Dali::Radian *argp3 ;
35782
35783   arg1 = (Dali::PanGestureDetector *)jarg1;
35784   argp2 = (Dali::Radian *)jarg2;
35785   if (!argp2) {
35786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35787     return ;
35788   }
35789   arg2 = *argp2;
35790   argp3 = (Dali::Radian *)jarg3;
35791   if (!argp3) {
35792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35793     return ;
35794   }
35795   arg3 = *argp3;
35796   {
35797     try {
35798       (arg1)->AddDirection(arg2,arg3);
35799     } catch (std::out_of_range& e) {
35800       {
35801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (std::exception& e) {
35804       {
35805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35810       };
35811     }
35812   }
35813 }
35814
35815
35816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35817   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35818   Dali::Radian arg2 ;
35819   Dali::Radian *argp2 ;
35820
35821   arg1 = (Dali::PanGestureDetector *)jarg1;
35822   argp2 = (Dali::Radian *)jarg2;
35823   if (!argp2) {
35824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35825     return ;
35826   }
35827   arg2 = *argp2;
35828   {
35829     try {
35830       (arg1)->AddDirection(arg2);
35831     } catch (std::out_of_range& e) {
35832       {
35833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35834       };
35835     } catch (std::exception& e) {
35836       {
35837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35842       };
35843     }
35844   }
35845 }
35846
35847
35848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35849   unsigned long jresult ;
35850   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35851   size_t result;
35852
35853   arg1 = (Dali::PanGestureDetector *)jarg1;
35854   {
35855     try {
35856       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35857     } catch (std::out_of_range& e) {
35858       {
35859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35860       };
35861     } catch (std::exception& e) {
35862       {
35863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35868       };
35869     }
35870   }
35871   jresult = (unsigned long)result;
35872   return jresult;
35873 }
35874
35875
35876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35877   void * jresult ;
35878   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35879   size_t arg2 ;
35880   Dali::PanGestureDetector::AngleThresholdPair result;
35881
35882   arg1 = (Dali::PanGestureDetector *)jarg1;
35883   arg2 = (size_t)jarg2;
35884   {
35885     try {
35886       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35887     } catch (std::out_of_range& e) {
35888       {
35889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35890       };
35891     } catch (std::exception& e) {
35892       {
35893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35898       };
35899     }
35900   }
35901   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35902   return jresult;
35903 }
35904
35905
35906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35907   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35908
35909   arg1 = (Dali::PanGestureDetector *)jarg1;
35910   {
35911     try {
35912       (arg1)->ClearAngles();
35913     } catch (std::out_of_range& e) {
35914       {
35915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35916       };
35917     } catch (std::exception& e) {
35918       {
35919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (...) {
35922       {
35923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35924       };
35925     }
35926   }
35927 }
35928
35929
35930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35931   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35932   Dali::Radian arg2 ;
35933   Dali::Radian *argp2 ;
35934
35935   arg1 = (Dali::PanGestureDetector *)jarg1;
35936   argp2 = (Dali::Radian *)jarg2;
35937   if (!argp2) {
35938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35939     return ;
35940   }
35941   arg2 = *argp2;
35942   {
35943     try {
35944       (arg1)->RemoveAngle(arg2);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (...) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35956       };
35957     }
35958   }
35959 }
35960
35961
35962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35963   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35964   Dali::Radian arg2 ;
35965   Dali::Radian *argp2 ;
35966
35967   arg1 = (Dali::PanGestureDetector *)jarg1;
35968   argp2 = (Dali::Radian *)jarg2;
35969   if (!argp2) {
35970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35971     return ;
35972   }
35973   arg2 = *argp2;
35974   {
35975     try {
35976       (arg1)->RemoveDirection(arg2);
35977     } catch (std::out_of_range& e) {
35978       {
35979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35980       };
35981     } catch (std::exception& e) {
35982       {
35983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35984       };
35985     } catch (...) {
35986       {
35987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35988       };
35989     }
35990   }
35991 }
35992
35993
35994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35995   void * jresult ;
35996   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35997   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35998
35999   arg1 = (Dali::PanGestureDetector *)jarg1;
36000   {
36001     try {
36002       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36003     } catch (std::out_of_range& e) {
36004       {
36005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36006       };
36007     } catch (std::exception& e) {
36008       {
36009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36010       };
36011     } catch (...) {
36012       {
36013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36014       };
36015     }
36016   }
36017   jresult = (void *)result;
36018   return jresult;
36019 }
36020
36021
36022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36023   Dali::PanGesture *arg1 = 0 ;
36024
36025   arg1 = (Dali::PanGesture *)jarg1;
36026   if (!arg1) {
36027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36028     return ;
36029   }
36030   {
36031     try {
36032       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36044       };
36045     }
36046   }
36047 }
36048
36049
36050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36051   void * jresult ;
36052   Dali::PanGesture *result = 0 ;
36053
36054   {
36055     try {
36056       result = (Dali::PanGesture *)new Dali::PanGesture();
36057     } catch (std::out_of_range& e) {
36058       {
36059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (std::exception& e) {
36062       {
36063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071   jresult = (void *)result;
36072   return jresult;
36073 }
36074
36075
36076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36077   void * jresult ;
36078   Dali::Gesture::State arg1 ;
36079   Dali::PanGesture *result = 0 ;
36080
36081   arg1 = (Dali::Gesture::State)jarg1;
36082   {
36083     try {
36084       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36085     } catch (std::out_of_range& e) {
36086       {
36087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36088       };
36089     } catch (std::exception& e) {
36090       {
36091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36096       };
36097     }
36098   }
36099   jresult = (void *)result;
36100   return jresult;
36101 }
36102
36103
36104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36105   void * jresult ;
36106   Dali::PanGesture *arg1 = 0 ;
36107   Dali::PanGesture *result = 0 ;
36108
36109   arg1 = (Dali::PanGesture *)jarg1;
36110   if (!arg1) {
36111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36112     return 0;
36113   }
36114   {
36115     try {
36116       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (...) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36128       };
36129     }
36130   }
36131   jresult = (void *)result;
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36137   void * jresult ;
36138   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36139   Dali::PanGesture *arg2 = 0 ;
36140   Dali::PanGesture *result = 0 ;
36141
36142   arg1 = (Dali::PanGesture *)jarg1;
36143   arg2 = (Dali::PanGesture *)jarg2;
36144   if (!arg2) {
36145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36146     return 0;
36147   }
36148   {
36149     try {
36150       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (...) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36162       };
36163     }
36164   }
36165   jresult = (void *)result;
36166   return jresult;
36167 }
36168
36169
36170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36171   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   {
36175     try {
36176       delete arg1;
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (...) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36188       };
36189     }
36190   }
36191 }
36192
36193
36194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36197
36198   arg1 = (Dali::PanGesture *)jarg1;
36199   arg2 = (Dali::Vector2 *)jarg2;
36200   if (arg1) (arg1)->velocity = *arg2;
36201 }
36202
36203
36204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36205   void * jresult ;
36206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36207   Dali::Vector2 *result = 0 ;
36208
36209   arg1 = (Dali::PanGesture *)jarg1;
36210   result = (Dali::Vector2 *)& ((arg1)->velocity);
36211   jresult = (void *)result;
36212   return jresult;
36213 }
36214
36215
36216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36219
36220   arg1 = (Dali::PanGesture *)jarg1;
36221   arg2 = (Dali::Vector2 *)jarg2;
36222   if (arg1) (arg1)->displacement = *arg2;
36223 }
36224
36225
36226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36227   void * jresult ;
36228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36229   Dali::Vector2 *result = 0 ;
36230
36231   arg1 = (Dali::PanGesture *)jarg1;
36232   result = (Dali::Vector2 *)& ((arg1)->displacement);
36233   jresult = (void *)result;
36234   return jresult;
36235 }
36236
36237
36238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36240   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36241
36242   arg1 = (Dali::PanGesture *)jarg1;
36243   arg2 = (Dali::Vector2 *)jarg2;
36244   if (arg1) (arg1)->position = *arg2;
36245 }
36246
36247
36248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36249   void * jresult ;
36250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36251   Dali::Vector2 *result = 0 ;
36252
36253   arg1 = (Dali::PanGesture *)jarg1;
36254   result = (Dali::Vector2 *)& ((arg1)->position);
36255   jresult = (void *)result;
36256   return jresult;
36257 }
36258
36259
36260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36262   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36263
36264   arg1 = (Dali::PanGesture *)jarg1;
36265   arg2 = (Dali::Vector2 *)jarg2;
36266   if (arg1) (arg1)->screenVelocity = *arg2;
36267 }
36268
36269
36270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36271   void * jresult ;
36272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36273   Dali::Vector2 *result = 0 ;
36274
36275   arg1 = (Dali::PanGesture *)jarg1;
36276   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36277   jresult = (void *)result;
36278   return jresult;
36279 }
36280
36281
36282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36284   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36285
36286   arg1 = (Dali::PanGesture *)jarg1;
36287   arg2 = (Dali::Vector2 *)jarg2;
36288   if (arg1) (arg1)->screenDisplacement = *arg2;
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36293   void * jresult ;
36294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36295   Dali::Vector2 *result = 0 ;
36296
36297   arg1 = (Dali::PanGesture *)jarg1;
36298   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36299   jresult = (void *)result;
36300   return jresult;
36301 }
36302
36303
36304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   arg2 = (Dali::Vector2 *)jarg2;
36310   if (arg1) (arg1)->screenPosition = *arg2;
36311 }
36312
36313
36314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36315   void * jresult ;
36316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36317   Dali::Vector2 *result = 0 ;
36318
36319   arg1 = (Dali::PanGesture *)jarg1;
36320   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36321   jresult = (void *)result;
36322   return jresult;
36323 }
36324
36325
36326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36327   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36328   unsigned int arg2 ;
36329
36330   arg1 = (Dali::PanGesture *)jarg1;
36331   arg2 = (unsigned int)jarg2;
36332   if (arg1) (arg1)->numberOfTouches = arg2;
36333 }
36334
36335
36336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36337   unsigned int jresult ;
36338   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36339   unsigned int result;
36340
36341   arg1 = (Dali::PanGesture *)jarg1;
36342   result = (unsigned int) ((arg1)->numberOfTouches);
36343   jresult = result;
36344   return jresult;
36345 }
36346
36347
36348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36349   float jresult ;
36350   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36351   float result;
36352
36353   arg1 = (Dali::PanGesture *)jarg1;
36354   {
36355     try {
36356       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36377   float jresult ;
36378   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36379   float result;
36380
36381   arg1 = (Dali::PanGesture *)jarg1;
36382   {
36383     try {
36384       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (...) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36396       };
36397     }
36398   }
36399   jresult = result;
36400   return jresult;
36401 }
36402
36403
36404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36405   float jresult ;
36406   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36407   float result;
36408
36409   arg1 = (Dali::PanGesture *)jarg1;
36410   {
36411     try {
36412       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36413     } catch (std::out_of_range& e) {
36414       {
36415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (std::exception& e) {
36418       {
36419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36420       };
36421     } catch (...) {
36422       {
36423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36424       };
36425     }
36426   }
36427   jresult = result;
36428   return jresult;
36429 }
36430
36431
36432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36433   float jresult ;
36434   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36435   float result;
36436
36437   arg1 = (Dali::PanGesture *)jarg1;
36438   {
36439     try {
36440       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36441     } catch (std::out_of_range& e) {
36442       {
36443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36444       };
36445     } catch (std::exception& e) {
36446       {
36447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36448       };
36449     } catch (...) {
36450       {
36451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36452       };
36453     }
36454   }
36455   jresult = result;
36456   return jresult;
36457 }
36458
36459
36460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36461   void * jresult ;
36462   Dali::PinchGestureDetector *result = 0 ;
36463
36464   {
36465     try {
36466       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36467     } catch (std::out_of_range& e) {
36468       {
36469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (std::exception& e) {
36472       {
36473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36474       };
36475     } catch (...) {
36476       {
36477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36478       };
36479     }
36480   }
36481   jresult = (void *)result;
36482   return jresult;
36483 }
36484
36485
36486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36487   void * jresult ;
36488   Dali::PinchGestureDetector result;
36489
36490   {
36491     try {
36492       result = Dali::PinchGestureDetector::New();
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (...) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36504       };
36505     }
36506   }
36507   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36513   void * jresult ;
36514   Dali::BaseHandle arg1 ;
36515   Dali::BaseHandle *argp1 ;
36516   Dali::PinchGestureDetector result;
36517
36518   argp1 = (Dali::BaseHandle *)jarg1;
36519   if (!argp1) {
36520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36521     return 0;
36522   }
36523   arg1 = *argp1;
36524   {
36525     try {
36526       result = Dali::PinchGestureDetector::DownCast(arg1);
36527     } catch (std::out_of_range& e) {
36528       {
36529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (std::exception& e) {
36532       {
36533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36534       };
36535     } catch (...) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36538       };
36539     }
36540   }
36541   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36542   return jresult;
36543 }
36544
36545
36546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36547   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36548
36549   arg1 = (Dali::PinchGestureDetector *)jarg1;
36550   {
36551     try {
36552       delete arg1;
36553     } catch (std::out_of_range& e) {
36554       {
36555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36556       };
36557     } catch (std::exception& e) {
36558       {
36559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (...) {
36562       {
36563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36564       };
36565     }
36566   }
36567 }
36568
36569
36570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36571   void * jresult ;
36572   Dali::PinchGestureDetector *arg1 = 0 ;
36573   Dali::PinchGestureDetector *result = 0 ;
36574
36575   arg1 = (Dali::PinchGestureDetector *)jarg1;
36576   if (!arg1) {
36577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36578     return 0;
36579   }
36580   {
36581     try {
36582       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36583     } catch (std::out_of_range& e) {
36584       {
36585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36586       };
36587     } catch (std::exception& e) {
36588       {
36589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36590       };
36591     } catch (...) {
36592       {
36593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36594       };
36595     }
36596   }
36597   jresult = (void *)result;
36598   return jresult;
36599 }
36600
36601
36602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36603   void * jresult ;
36604   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36605   Dali::PinchGestureDetector *arg2 = 0 ;
36606   Dali::PinchGestureDetector *result = 0 ;
36607
36608   arg1 = (Dali::PinchGestureDetector *)jarg1;
36609   arg2 = (Dali::PinchGestureDetector *)jarg2;
36610   if (!arg2) {
36611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36612     return 0;
36613   }
36614   {
36615     try {
36616       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36617     } catch (std::out_of_range& e) {
36618       {
36619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36620       };
36621     } catch (std::exception& e) {
36622       {
36623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36624       };
36625     } catch (...) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36628       };
36629     }
36630   }
36631   jresult = (void *)result;
36632   return jresult;
36633 }
36634
36635
36636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36637   void * jresult ;
36638   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36639   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36640
36641   arg1 = (Dali::PinchGestureDetector *)jarg1;
36642   {
36643     try {
36644       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36645     } catch (std::out_of_range& e) {
36646       {
36647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36648       };
36649     } catch (std::exception& e) {
36650       {
36651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36652       };
36653     } catch (...) {
36654       {
36655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36656       };
36657     }
36658   }
36659   jresult = (void *)result;
36660   return jresult;
36661 }
36662
36663
36664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36665   void * jresult ;
36666   Dali::Gesture::State arg1 ;
36667   Dali::PinchGesture *result = 0 ;
36668
36669   arg1 = (Dali::Gesture::State)jarg1;
36670   {
36671     try {
36672       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36673     } catch (std::out_of_range& e) {
36674       {
36675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36676       };
36677     } catch (std::exception& e) {
36678       {
36679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36684       };
36685     }
36686   }
36687   jresult = (void *)result;
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36693   void * jresult ;
36694   Dali::PinchGesture *arg1 = 0 ;
36695   Dali::PinchGesture *result = 0 ;
36696
36697   arg1 = (Dali::PinchGesture *)jarg1;
36698   if (!arg1) {
36699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36700     return 0;
36701   }
36702   {
36703     try {
36704       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36705     } catch (std::out_of_range& e) {
36706       {
36707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (std::exception& e) {
36710       {
36711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719   jresult = (void *)result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36725   void * jresult ;
36726   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36727   Dali::PinchGesture *arg2 = 0 ;
36728   Dali::PinchGesture *result = 0 ;
36729
36730   arg1 = (Dali::PinchGesture *)jarg1;
36731   arg2 = (Dali::PinchGesture *)jarg2;
36732   if (!arg2) {
36733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36734     return 0;
36735   }
36736   {
36737     try {
36738       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36739     } catch (std::out_of_range& e) {
36740       {
36741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36742       };
36743     } catch (std::exception& e) {
36744       {
36745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36746       };
36747     } catch (...) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36750       };
36751     }
36752   }
36753   jresult = (void *)result;
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   {
36763     try {
36764       delete arg1;
36765     } catch (std::out_of_range& e) {
36766       {
36767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36768       };
36769     } catch (std::exception& e) {
36770       {
36771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36772       };
36773     } catch (...) {
36774       {
36775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36776       };
36777     }
36778   }
36779 }
36780
36781
36782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36783   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36784   float arg2 ;
36785
36786   arg1 = (Dali::PinchGesture *)jarg1;
36787   arg2 = (float)jarg2;
36788   if (arg1) (arg1)->scale = arg2;
36789 }
36790
36791
36792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36793   float jresult ;
36794   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36795   float result;
36796
36797   arg1 = (Dali::PinchGesture *)jarg1;
36798   result = (float) ((arg1)->scale);
36799   jresult = result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36805   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36806   float arg2 ;
36807
36808   arg1 = (Dali::PinchGesture *)jarg1;
36809   arg2 = (float)jarg2;
36810   if (arg1) (arg1)->speed = arg2;
36811 }
36812
36813
36814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36815   float jresult ;
36816   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36817   float result;
36818
36819   arg1 = (Dali::PinchGesture *)jarg1;
36820   result = (float) ((arg1)->speed);
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36827   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36828   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36829
36830   arg1 = (Dali::PinchGesture *)jarg1;
36831   arg2 = (Dali::Vector2 *)jarg2;
36832   if (arg1) (arg1)->screenCenterPoint = *arg2;
36833 }
36834
36835
36836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36837   void * jresult ;
36838   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36839   Dali::Vector2 *result = 0 ;
36840
36841   arg1 = (Dali::PinchGesture *)jarg1;
36842   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36843   jresult = (void *)result;
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36849   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36850   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36851
36852   arg1 = (Dali::PinchGesture *)jarg1;
36853   arg2 = (Dali::Vector2 *)jarg2;
36854   if (arg1) (arg1)->localCenterPoint = *arg2;
36855 }
36856
36857
36858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36859   void * jresult ;
36860   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36861   Dali::Vector2 *result = 0 ;
36862
36863   arg1 = (Dali::PinchGesture *)jarg1;
36864   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36865   jresult = (void *)result;
36866   return jresult;
36867 }
36868
36869
36870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36871   void * jresult ;
36872   Dali::TapGestureDetector *result = 0 ;
36873
36874   {
36875     try {
36876       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (...) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36888       };
36889     }
36890   }
36891   jresult = (void *)result;
36892   return jresult;
36893 }
36894
36895
36896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36897   void * jresult ;
36898   Dali::TapGestureDetector result;
36899
36900   {
36901     try {
36902       result = Dali::TapGestureDetector::New();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (...) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36914       };
36915     }
36916   }
36917   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36918   return jresult;
36919 }
36920
36921
36922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36923   void * jresult ;
36924   unsigned int arg1 ;
36925   Dali::TapGestureDetector result;
36926
36927   arg1 = (unsigned int)jarg1;
36928   {
36929     try {
36930       result = Dali::TapGestureDetector::New(arg1);
36931     } catch (std::out_of_range& e) {
36932       {
36933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36934       };
36935     } catch (std::exception& e) {
36936       {
36937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36938       };
36939     } catch (...) {
36940       {
36941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36942       };
36943     }
36944   }
36945   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36946   return jresult;
36947 }
36948
36949
36950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36951   void * jresult ;
36952   Dali::BaseHandle arg1 ;
36953   Dali::BaseHandle *argp1 ;
36954   Dali::TapGestureDetector result;
36955
36956   argp1 = (Dali::BaseHandle *)jarg1;
36957   if (!argp1) {
36958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36959     return 0;
36960   }
36961   arg1 = *argp1;
36962   {
36963     try {
36964       result = Dali::TapGestureDetector::DownCast(arg1);
36965     } catch (std::out_of_range& e) {
36966       {
36967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36968       };
36969     } catch (std::exception& e) {
36970       {
36971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (...) {
36974       {
36975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36976       };
36977     }
36978   }
36979   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36985   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36986
36987   arg1 = (Dali::TapGestureDetector *)jarg1;
36988   {
36989     try {
36990       delete arg1;
36991     } catch (std::out_of_range& e) {
36992       {
36993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36994       };
36995     } catch (std::exception& e) {
36996       {
36997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36998       };
36999     } catch (...) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37002       };
37003     }
37004   }
37005 }
37006
37007
37008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37009   void * jresult ;
37010   Dali::TapGestureDetector *arg1 = 0 ;
37011   Dali::TapGestureDetector *result = 0 ;
37012
37013   arg1 = (Dali::TapGestureDetector *)jarg1;
37014   if (!arg1) {
37015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37016     return 0;
37017   }
37018   {
37019     try {
37020       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37021     } catch (std::out_of_range& e) {
37022       {
37023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37024       };
37025     } catch (std::exception& e) {
37026       {
37027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37028       };
37029     } catch (...) {
37030       {
37031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37032       };
37033     }
37034   }
37035   jresult = (void *)result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37041   void * jresult ;
37042   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37043   Dali::TapGestureDetector *arg2 = 0 ;
37044   Dali::TapGestureDetector *result = 0 ;
37045
37046   arg1 = (Dali::TapGestureDetector *)jarg1;
37047   arg2 = (Dali::TapGestureDetector *)jarg2;
37048   if (!arg2) {
37049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37050     return 0;
37051   }
37052   {
37053     try {
37054       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37055     } catch (std::out_of_range& e) {
37056       {
37057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (std::exception& e) {
37060       {
37061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37066       };
37067     }
37068   }
37069   jresult = (void *)result;
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37075   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37076   unsigned int arg2 ;
37077
37078   arg1 = (Dali::TapGestureDetector *)jarg1;
37079   arg2 = (unsigned int)jarg2;
37080   {
37081     try {
37082       (arg1)->SetMinimumTapsRequired(arg2);
37083     } catch (std::out_of_range& e) {
37084       {
37085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37086       };
37087     } catch (std::exception& e) {
37088       {
37089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37090       };
37091     } catch (...) {
37092       {
37093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37094       };
37095     }
37096   }
37097 }
37098
37099
37100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37101   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37102   unsigned int arg2 ;
37103
37104   arg1 = (Dali::TapGestureDetector *)jarg1;
37105   arg2 = (unsigned int)jarg2;
37106   {
37107     try {
37108       (arg1)->SetMaximumTapsRequired(arg2);
37109     } catch (std::out_of_range& e) {
37110       {
37111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37112       };
37113     } catch (std::exception& e) {
37114       {
37115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37120       };
37121     }
37122   }
37123 }
37124
37125
37126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37127   unsigned int jresult ;
37128   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37129   unsigned int result;
37130
37131   arg1 = (Dali::TapGestureDetector *)jarg1;
37132   {
37133     try {
37134       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37135     } catch (std::out_of_range& e) {
37136       {
37137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (std::exception& e) {
37140       {
37141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149   jresult = result;
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37155   unsigned int jresult ;
37156   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37157   unsigned int result;
37158
37159   arg1 = (Dali::TapGestureDetector *)jarg1;
37160   {
37161     try {
37162       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37163     } catch (std::out_of_range& e) {
37164       {
37165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37166       };
37167     } catch (std::exception& e) {
37168       {
37169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37170       };
37171     } catch (...) {
37172       {
37173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37174       };
37175     }
37176   }
37177   jresult = result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37183   void * jresult ;
37184   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37185   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37186
37187   arg1 = (Dali::TapGestureDetector *)jarg1;
37188   {
37189     try {
37190       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37191     } catch (std::out_of_range& e) {
37192       {
37193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (std::exception& e) {
37196       {
37197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205   jresult = (void *)result;
37206   return jresult;
37207 }
37208
37209
37210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37211   void * jresult ;
37212   Dali::TapGesture *result = 0 ;
37213
37214   {
37215     try {
37216       result = (Dali::TapGesture *)new Dali::TapGesture();
37217     } catch (std::out_of_range& e) {
37218       {
37219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37220       };
37221     } catch (std::exception& e) {
37222       {
37223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37224       };
37225     } catch (...) {
37226       {
37227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37228       };
37229     }
37230   }
37231   jresult = (void *)result;
37232   return jresult;
37233 }
37234
37235
37236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37237   void * jresult ;
37238   Dali::TapGesture *arg1 = 0 ;
37239   Dali::TapGesture *result = 0 ;
37240
37241   arg1 = (Dali::TapGesture *)jarg1;
37242   if (!arg1) {
37243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37244     return 0;
37245   }
37246   {
37247     try {
37248       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37249     } catch (std::out_of_range& e) {
37250       {
37251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37252       };
37253     } catch (std::exception& e) {
37254       {
37255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (...) {
37258       {
37259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37260       };
37261     }
37262   }
37263   jresult = (void *)result;
37264   return jresult;
37265 }
37266
37267
37268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37269   void * jresult ;
37270   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37271   Dali::TapGesture *arg2 = 0 ;
37272   Dali::TapGesture *result = 0 ;
37273
37274   arg1 = (Dali::TapGesture *)jarg1;
37275   arg2 = (Dali::TapGesture *)jarg2;
37276   if (!arg2) {
37277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37278     return 0;
37279   }
37280   {
37281     try {
37282       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37290       };
37291     } catch (...) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37294       };
37295     }
37296   }
37297   jresult = (void *)result;
37298   return jresult;
37299 }
37300
37301
37302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37303   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   {
37307     try {
37308       delete arg1;
37309     } catch (std::out_of_range& e) {
37310       {
37311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37312       };
37313     } catch (std::exception& e) {
37314       {
37315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37316       };
37317     } catch (...) {
37318       {
37319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37320       };
37321     }
37322   }
37323 }
37324
37325
37326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37327   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37328   unsigned int arg2 ;
37329
37330   arg1 = (Dali::TapGesture *)jarg1;
37331   arg2 = (unsigned int)jarg2;
37332   if (arg1) (arg1)->numberOfTaps = arg2;
37333 }
37334
37335
37336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37337   unsigned int jresult ;
37338   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37339   unsigned int result;
37340
37341   arg1 = (Dali::TapGesture *)jarg1;
37342   result = (unsigned int) ((arg1)->numberOfTaps);
37343   jresult = result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37349   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37350   unsigned int arg2 ;
37351
37352   arg1 = (Dali::TapGesture *)jarg1;
37353   arg2 = (unsigned int)jarg2;
37354   if (arg1) (arg1)->numberOfTouches = arg2;
37355 }
37356
37357
37358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37359   unsigned int jresult ;
37360   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37361   unsigned int result;
37362
37363   arg1 = (Dali::TapGesture *)jarg1;
37364   result = (unsigned int) ((arg1)->numberOfTouches);
37365   jresult = result;
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37371   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37373
37374   arg1 = (Dali::TapGesture *)jarg1;
37375   arg2 = (Dali::Vector2 *)jarg2;
37376   if (arg1) (arg1)->screenPoint = *arg2;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37381   void * jresult ;
37382   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37383   Dali::Vector2 *result = 0 ;
37384
37385   arg1 = (Dali::TapGesture *)jarg1;
37386   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37393   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37394   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37395
37396   arg1 = (Dali::TapGesture *)jarg1;
37397   arg2 = (Dali::Vector2 *)jarg2;
37398   if (arg1) (arg1)->localPoint = *arg2;
37399 }
37400
37401
37402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37403   void * jresult ;
37404   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37405   Dali::Vector2 *result = 0 ;
37406
37407   arg1 = (Dali::TapGesture *)jarg1;
37408   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37409   jresult = (void *)result;
37410   return jresult;
37411 }
37412
37413
37414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37415   void * jresult ;
37416   Dali::AlphaFunction *result = 0 ;
37417
37418   {
37419     try {
37420       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37421     } catch (std::out_of_range& e) {
37422       {
37423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37424       };
37425     } catch (std::exception& e) {
37426       {
37427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37428       };
37429     } catch (...) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37432       };
37433     }
37434   }
37435   jresult = (void *)result;
37436   return jresult;
37437 }
37438
37439
37440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37441   void * jresult ;
37442   Dali::AlphaFunction::BuiltinFunction arg1 ;
37443   Dali::AlphaFunction *result = 0 ;
37444
37445   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37446   {
37447     try {
37448       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37449     } catch (std::out_of_range& e) {
37450       {
37451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37452       };
37453     } catch (std::exception& e) {
37454       {
37455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37456       };
37457     } catch (...) {
37458       {
37459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37460       };
37461     }
37462   }
37463   jresult = (void *)result;
37464   return jresult;
37465 }
37466
37467
37468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37469   void * jresult ;
37470   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37471   Dali::AlphaFunction *result = 0 ;
37472
37473   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37474   {
37475     try {
37476       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37484       };
37485     } catch (...) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37488       };
37489     }
37490   }
37491   jresult = (void *)result;
37492   return jresult;
37493 }
37494
37495
37496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37497   void * jresult ;
37498   Dali::Vector2 *arg1 = 0 ;
37499   Dali::Vector2 *arg2 = 0 ;
37500   Dali::AlphaFunction *result = 0 ;
37501
37502   arg1 = (Dali::Vector2 *)jarg1;
37503   if (!arg1) {
37504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37505     return 0;
37506   }
37507   arg2 = (Dali::Vector2 *)jarg2;
37508   if (!arg2) {
37509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37510     return 0;
37511   }
37512   {
37513     try {
37514       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37515     } catch (std::out_of_range& e) {
37516       {
37517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37518       };
37519     } catch (std::exception& e) {
37520       {
37521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37526       };
37527     }
37528   }
37529   jresult = (void *)result;
37530   return jresult;
37531 }
37532
37533
37534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37535   void * jresult ;
37536   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37537   Dali::Vector4 result;
37538
37539   arg1 = (Dali::AlphaFunction *)jarg1;
37540   {
37541     try {
37542       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37543     } catch (std::out_of_range& e) {
37544       {
37545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37546       };
37547     } catch (std::exception& e) {
37548       {
37549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37550       };
37551     } catch (...) {
37552       {
37553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37554       };
37555     }
37556   }
37557   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37558   return jresult;
37559 }
37560
37561
37562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37563   void * jresult ;
37564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37565   Dali::AlphaFunctionPrototype result;
37566
37567   arg1 = (Dali::AlphaFunction *)jarg1;
37568   {
37569     try {
37570       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37571     } catch (std::out_of_range& e) {
37572       {
37573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37574       };
37575     } catch (std::exception& e) {
37576       {
37577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37578       };
37579     } catch (...) {
37580       {
37581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37582       };
37583     }
37584   }
37585   jresult = (void *)result;
37586   return jresult;
37587 }
37588
37589
37590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37591   int jresult ;
37592   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37593   Dali::AlphaFunction::BuiltinFunction result;
37594
37595   arg1 = (Dali::AlphaFunction *)jarg1;
37596   {
37597     try {
37598       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37606       };
37607     } catch (...) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37610       };
37611     }
37612   }
37613   jresult = (int)result;
37614   return jresult;
37615 }
37616
37617
37618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37619   int jresult ;
37620   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37621   Dali::AlphaFunction::Mode result;
37622
37623   arg1 = (Dali::AlphaFunction *)jarg1;
37624   {
37625     try {
37626       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37627     } catch (std::out_of_range& e) {
37628       {
37629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37630       };
37631     } catch (std::exception& e) {
37632       {
37633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37638       };
37639     }
37640   }
37641   jresult = (int)result;
37642   return jresult;
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37647   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37648
37649   arg1 = (Dali::AlphaFunction *)jarg1;
37650   {
37651     try {
37652       delete arg1;
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (...) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37664       };
37665     }
37666   }
37667 }
37668
37669
37670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37671   void * jresult ;
37672   Dali::KeyFrames result;
37673
37674   {
37675     try {
37676       result = Dali::KeyFrames::New();
37677     } catch (std::out_of_range& e) {
37678       {
37679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37680       };
37681     } catch (std::exception& e) {
37682       {
37683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37684       };
37685     } catch (...) {
37686       {
37687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37688       };
37689     }
37690   }
37691   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37692   return jresult;
37693 }
37694
37695
37696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37697   void * jresult ;
37698   Dali::BaseHandle arg1 ;
37699   Dali::BaseHandle *argp1 ;
37700   Dali::KeyFrames result;
37701
37702   argp1 = (Dali::BaseHandle *)jarg1;
37703   if (!argp1) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37705     return 0;
37706   }
37707   arg1 = *argp1;
37708   {
37709     try {
37710       result = Dali::KeyFrames::DownCast(arg1);
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (...) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37722       };
37723     }
37724   }
37725   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37726   return jresult;
37727 }
37728
37729
37730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37731   void * jresult ;
37732   Dali::KeyFrames *result = 0 ;
37733
37734   {
37735     try {
37736       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37737     } catch (std::out_of_range& e) {
37738       {
37739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37740       };
37741     } catch (std::exception& e) {
37742       {
37743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37748       };
37749     }
37750   }
37751   jresult = (void *)result;
37752   return jresult;
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37757   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37758
37759   arg1 = (Dali::KeyFrames *)jarg1;
37760   {
37761     try {
37762       delete arg1;
37763     } catch (std::out_of_range& e) {
37764       {
37765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37766       };
37767     } catch (std::exception& e) {
37768       {
37769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37770       };
37771     } catch (...) {
37772       {
37773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37774       };
37775     }
37776   }
37777 }
37778
37779
37780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37781   void * jresult ;
37782   Dali::KeyFrames *arg1 = 0 ;
37783   Dali::KeyFrames *result = 0 ;
37784
37785   arg1 = (Dali::KeyFrames *)jarg1;
37786   if (!arg1) {
37787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37788     return 0;
37789   }
37790   {
37791     try {
37792       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37804       };
37805     }
37806   }
37807   jresult = (void *)result;
37808   return jresult;
37809 }
37810
37811
37812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37813   void * jresult ;
37814   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37815   Dali::KeyFrames *arg2 = 0 ;
37816   Dali::KeyFrames *result = 0 ;
37817
37818   arg1 = (Dali::KeyFrames *)jarg1;
37819   arg2 = (Dali::KeyFrames *)jarg2;
37820   if (!arg2) {
37821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37822     return 0;
37823   }
37824   {
37825     try {
37826       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37827     } catch (std::out_of_range& e) {
37828       {
37829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37830       };
37831     } catch (std::exception& e) {
37832       {
37833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37838       };
37839     }
37840   }
37841   jresult = (void *)result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37847   int jresult ;
37848   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37849   Dali::Property::Type result;
37850
37851   arg1 = (Dali::KeyFrames *)jarg1;
37852   {
37853     try {
37854       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37855     } catch (std::out_of_range& e) {
37856       {
37857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37858       };
37859     } catch (std::exception& e) {
37860       {
37861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37862       };
37863     } catch (...) {
37864       {
37865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37866       };
37867     }
37868   }
37869   jresult = (int)result;
37870   return jresult;
37871 }
37872
37873
37874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37875   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37876   float arg2 ;
37877   Dali::Property::Value arg3 ;
37878   Dali::Property::Value *argp3 ;
37879
37880   arg1 = (Dali::KeyFrames *)jarg1;
37881   arg2 = (float)jarg2;
37882   argp3 = (Dali::Property::Value *)jarg3;
37883   if (!argp3) {
37884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37885     return ;
37886   }
37887   arg3 = *argp3;
37888   {
37889     try {
37890       (arg1)->Add(arg2,arg3);
37891     } catch (std::out_of_range& e) {
37892       {
37893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (std::exception& e) {
37896       {
37897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905 }
37906
37907
37908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37909   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37910   float arg2 ;
37911   Dali::Property::Value arg3 ;
37912   Dali::AlphaFunction arg4 ;
37913   Dali::Property::Value *argp3 ;
37914   Dali::AlphaFunction *argp4 ;
37915
37916   arg1 = (Dali::KeyFrames *)jarg1;
37917   arg2 = (float)jarg2;
37918   argp3 = (Dali::Property::Value *)jarg3;
37919   if (!argp3) {
37920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37921     return ;
37922   }
37923   arg3 = *argp3;
37924   argp4 = (Dali::AlphaFunction *)jarg4;
37925   if (!argp4) {
37926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37927     return ;
37928   }
37929   arg4 = *argp4;
37930   {
37931     try {
37932       (arg1)->Add(arg2,arg3,arg4);
37933     } catch (std::out_of_range& e) {
37934       {
37935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37936       };
37937     } catch (std::exception& e) {
37938       {
37939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37944       };
37945     }
37946   }
37947 }
37948
37949
37950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37951   int jresult ;
37952   int result;
37953
37954   result = (int)Dali::Path::Property::POINTS;
37955   jresult = (int)result;
37956   return jresult;
37957 }
37958
37959
37960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37961   int jresult ;
37962   int result;
37963
37964   result = (int)Dali::Path::Property::CONTROL_POINTS;
37965   jresult = (int)result;
37966   return jresult;
37967 }
37968
37969
37970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37971   void * jresult ;
37972   Dali::Path::Property *result = 0 ;
37973
37974   {
37975     try {
37976       result = (Dali::Path::Property *)new Dali::Path::Property();
37977     } catch (std::out_of_range& e) {
37978       {
37979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37980       };
37981     } catch (std::exception& e) {
37982       {
37983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (...) {
37986       {
37987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37988       };
37989     }
37990   }
37991   jresult = (void *)result;
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37997   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37998
37999   arg1 = (Dali::Path::Property *)jarg1;
38000   {
38001     try {
38002       delete arg1;
38003     } catch (std::out_of_range& e) {
38004       {
38005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38006       };
38007     } catch (std::exception& e) {
38008       {
38009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38014       };
38015     }
38016   }
38017 }
38018
38019
38020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38021   void * jresult ;
38022   Dali::Path result;
38023
38024   {
38025     try {
38026       result = Dali::Path::New();
38027     } catch (std::out_of_range& e) {
38028       {
38029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38030       };
38031     } catch (std::exception& e) {
38032       {
38033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38034       };
38035     } catch (...) {
38036       {
38037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38038       };
38039     }
38040   }
38041   jresult = new Dali::Path((const Dali::Path &)result);
38042   return jresult;
38043 }
38044
38045
38046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38047   void * jresult ;
38048   Dali::BaseHandle arg1 ;
38049   Dali::BaseHandle *argp1 ;
38050   Dali::Path result;
38051
38052   argp1 = (Dali::BaseHandle *)jarg1;
38053   if (!argp1) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38055     return 0;
38056   }
38057   arg1 = *argp1;
38058   {
38059     try {
38060       result = Dali::Path::DownCast(arg1);
38061     } catch (std::out_of_range& e) {
38062       {
38063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38064       };
38065     } catch (std::exception& e) {
38066       {
38067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38072       };
38073     }
38074   }
38075   jresult = new Dali::Path((const Dali::Path &)result);
38076   return jresult;
38077 }
38078
38079
38080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38081   void * jresult ;
38082   Dali::Path *result = 0 ;
38083
38084   {
38085     try {
38086       result = (Dali::Path *)new Dali::Path();
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101   jresult = (void *)result;
38102   return jresult;
38103 }
38104
38105
38106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38107   Dali::Path *arg1 = (Dali::Path *) 0 ;
38108
38109   arg1 = (Dali::Path *)jarg1;
38110   {
38111     try {
38112       delete arg1;
38113     } catch (std::out_of_range& e) {
38114       {
38115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38116       };
38117     } catch (std::exception& e) {
38118       {
38119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38120       };
38121     } catch (...) {
38122       {
38123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38124       };
38125     }
38126   }
38127 }
38128
38129
38130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38131   void * jresult ;
38132   Dali::Path *arg1 = 0 ;
38133   Dali::Path *result = 0 ;
38134
38135   arg1 = (Dali::Path *)jarg1;
38136   if (!arg1) {
38137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38138     return 0;
38139   }
38140   {
38141     try {
38142       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38143     } catch (std::out_of_range& e) {
38144       {
38145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38146       };
38147     } catch (std::exception& e) {
38148       {
38149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38150       };
38151     } catch (...) {
38152       {
38153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38154       };
38155     }
38156   }
38157   jresult = (void *)result;
38158   return jresult;
38159 }
38160
38161
38162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38163   void * jresult ;
38164   Dali::Path *arg1 = (Dali::Path *) 0 ;
38165   Dali::Path *arg2 = 0 ;
38166   Dali::Path *result = 0 ;
38167
38168   arg1 = (Dali::Path *)jarg1;
38169   arg2 = (Dali::Path *)jarg2;
38170   if (!arg2) {
38171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38172     return 0;
38173   }
38174   {
38175     try {
38176       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38177     } catch (std::out_of_range& e) {
38178       {
38179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38180       };
38181     } catch (std::exception& e) {
38182       {
38183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (...) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38188       };
38189     }
38190   }
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38197   Dali::Path *arg1 = (Dali::Path *) 0 ;
38198   Dali::Vector3 *arg2 = 0 ;
38199
38200   arg1 = (Dali::Path *)jarg1;
38201   arg2 = (Dali::Vector3 *)jarg2;
38202   if (!arg2) {
38203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38204     return ;
38205   }
38206   {
38207     try {
38208       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38216       };
38217     } catch (...) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38220       };
38221     }
38222   }
38223 }
38224
38225
38226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38227   Dali::Path *arg1 = (Dali::Path *) 0 ;
38228   Dali::Vector3 *arg2 = 0 ;
38229
38230   arg1 = (Dali::Path *)jarg1;
38231   arg2 = (Dali::Vector3 *)jarg2;
38232   if (!arg2) {
38233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38234     return ;
38235   }
38236   {
38237     try {
38238       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38239     } catch (std::out_of_range& e) {
38240       {
38241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38242       };
38243     } catch (std::exception& e) {
38244       {
38245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38246       };
38247     } catch (...) {
38248       {
38249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38250       };
38251     }
38252   }
38253 }
38254
38255
38256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38257   Dali::Path *arg1 = (Dali::Path *) 0 ;
38258   float arg2 ;
38259
38260   arg1 = (Dali::Path *)jarg1;
38261   arg2 = (float)jarg2;
38262   {
38263     try {
38264       (arg1)->GenerateControlPoints(arg2);
38265     } catch (std::out_of_range& e) {
38266       {
38267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38268       };
38269     } catch (std::exception& e) {
38270       {
38271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38272       };
38273     } catch (...) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38276       };
38277     }
38278   }
38279 }
38280
38281
38282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38283   Dali::Path *arg1 = (Dali::Path *) 0 ;
38284   float arg2 ;
38285   Dali::Vector3 *arg3 = 0 ;
38286   Dali::Vector3 *arg4 = 0 ;
38287
38288   arg1 = (Dali::Path *)jarg1;
38289   arg2 = (float)jarg2;
38290   arg3 = (Dali::Vector3 *)jarg3;
38291   if (!arg3) {
38292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38293     return ;
38294   }
38295   arg4 = (Dali::Vector3 *)jarg4;
38296   if (!arg4) {
38297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38298     return ;
38299   }
38300   {
38301     try {
38302       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38314       };
38315     }
38316   }
38317 }
38318
38319
38320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38321   void * jresult ;
38322   Dali::Path *arg1 = (Dali::Path *) 0 ;
38323   size_t arg2 ;
38324   Dali::Vector3 *result = 0 ;
38325
38326   arg1 = (Dali::Path *)jarg1;
38327   arg2 = (size_t)jarg2;
38328   {
38329     try {
38330       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (...) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38342       };
38343     }
38344   }
38345   jresult = (void *)result;
38346   return jresult;
38347 }
38348
38349
38350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38351   void * jresult ;
38352   Dali::Path *arg1 = (Dali::Path *) 0 ;
38353   size_t arg2 ;
38354   Dali::Vector3 *result = 0 ;
38355
38356   arg1 = (Dali::Path *)jarg1;
38357   arg2 = (size_t)jarg2;
38358   {
38359     try {
38360       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375   jresult = (void *)result;
38376   return jresult;
38377 }
38378
38379
38380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38381   unsigned long jresult ;
38382   Dali::Path *arg1 = (Dali::Path *) 0 ;
38383   size_t result;
38384
38385   arg1 = (Dali::Path *)jarg1;
38386   {
38387     try {
38388       result = ((Dali::Path const *)arg1)->GetPointCount();
38389     } catch (std::out_of_range& e) {
38390       {
38391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38392       };
38393     } catch (std::exception& e) {
38394       {
38395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38400       };
38401     }
38402   }
38403   jresult = (unsigned long)result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38409   void * jresult ;
38410   float arg1 ;
38411   Dali::TimePeriod *result = 0 ;
38412
38413   arg1 = (float)jarg1;
38414   {
38415     try {
38416       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (...) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38428       };
38429     }
38430   }
38431   jresult = (void *)result;
38432   return jresult;
38433 }
38434
38435
38436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38437   void * jresult ;
38438   float arg1 ;
38439   float arg2 ;
38440   Dali::TimePeriod *result = 0 ;
38441
38442   arg1 = (float)jarg1;
38443   arg2 = (float)jarg2;
38444   {
38445     try {
38446       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38447     } catch (std::out_of_range& e) {
38448       {
38449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38450       };
38451     } catch (std::exception& e) {
38452       {
38453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (...) {
38456       {
38457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38458       };
38459     }
38460   }
38461   jresult = (void *)result;
38462   return jresult;
38463 }
38464
38465
38466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38467   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38468
38469   arg1 = (Dali::TimePeriod *)jarg1;
38470   {
38471     try {
38472       delete arg1;
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (...) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38484       };
38485     }
38486   }
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38491   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38492   float arg2 ;
38493
38494   arg1 = (Dali::TimePeriod *)jarg1;
38495   arg2 = (float)jarg2;
38496   if (arg1) (arg1)->delaySeconds = arg2;
38497 }
38498
38499
38500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38501   float jresult ;
38502   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38503   float result;
38504
38505   arg1 = (Dali::TimePeriod *)jarg1;
38506   result = (float) ((arg1)->delaySeconds);
38507   jresult = result;
38508   return jresult;
38509 }
38510
38511
38512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38513   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38514   float arg2 ;
38515
38516   arg1 = (Dali::TimePeriod *)jarg1;
38517   arg2 = (float)jarg2;
38518   if (arg1) (arg1)->durationSeconds = arg2;
38519 }
38520
38521
38522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38523   float jresult ;
38524   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38525   float result;
38526
38527   arg1 = (Dali::TimePeriod *)jarg1;
38528   result = (float) ((arg1)->durationSeconds);
38529   jresult = result;
38530   return jresult;
38531 }
38532
38533
38534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38535   void * jresult ;
38536   Dali::Animation *result = 0 ;
38537
38538   {
38539     try {
38540       result = (Dali::Animation *)new Dali::Animation();
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555   jresult = (void *)result;
38556   return jresult;
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38561   void * jresult ;
38562   float arg1 ;
38563   Dali::Animation result;
38564
38565   arg1 = (float)jarg1;
38566   {
38567     try {
38568       result = Dali::Animation::New(arg1);
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583   jresult = new Dali::Animation((const Dali::Animation &)result);
38584   return jresult;
38585 }
38586
38587
38588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38589   void * jresult ;
38590   Dali::BaseHandle arg1 ;
38591   Dali::BaseHandle *argp1 ;
38592   Dali::Animation result;
38593
38594   argp1 = (Dali::BaseHandle *)jarg1;
38595   if (!argp1) {
38596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38597     return 0;
38598   }
38599   arg1 = *argp1;
38600   {
38601     try {
38602       result = Dali::Animation::DownCast(arg1);
38603     } catch (std::out_of_range& e) {
38604       {
38605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38606       };
38607     } catch (std::exception& e) {
38608       {
38609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38614       };
38615     }
38616   }
38617   jresult = new Dali::Animation((const Dali::Animation &)result);
38618   return jresult;
38619 }
38620
38621
38622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38623   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38624
38625   arg1 = (Dali::Animation *)jarg1;
38626   {
38627     try {
38628       delete arg1;
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38640       };
38641     }
38642   }
38643 }
38644
38645
38646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38647   void * jresult ;
38648   Dali::Animation *arg1 = 0 ;
38649   Dali::Animation *result = 0 ;
38650
38651   arg1 = (Dali::Animation *)jarg1;
38652   if (!arg1) {
38653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38654     return 0;
38655   }
38656   {
38657     try {
38658       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38659     } catch (std::out_of_range& e) {
38660       {
38661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38662       };
38663     } catch (std::exception& e) {
38664       {
38665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (...) {
38668       {
38669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38670       };
38671     }
38672   }
38673   jresult = (void *)result;
38674   return jresult;
38675 }
38676
38677
38678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38679   void * jresult ;
38680   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38681   Dali::Animation *arg2 = 0 ;
38682   Dali::Animation *result = 0 ;
38683
38684   arg1 = (Dali::Animation *)jarg1;
38685   arg2 = (Dali::Animation *)jarg2;
38686   if (!arg2) {
38687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38688     return 0;
38689   }
38690   {
38691     try {
38692       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38693     } catch (std::out_of_range& e) {
38694       {
38695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38696       };
38697     } catch (std::exception& e) {
38698       {
38699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (...) {
38702       {
38703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38704       };
38705     }
38706   }
38707   jresult = (void *)result;
38708   return jresult;
38709 }
38710
38711
38712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38713   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38714   float arg2 ;
38715
38716   arg1 = (Dali::Animation *)jarg1;
38717   arg2 = (float)jarg2;
38718   {
38719     try {
38720       (arg1)->SetDuration(arg2);
38721     } catch (std::out_of_range& e) {
38722       {
38723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38724       };
38725     } catch (std::exception& e) {
38726       {
38727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38728       };
38729     } catch (...) {
38730       {
38731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38732       };
38733     }
38734   }
38735 }
38736
38737
38738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38739   float jresult ;
38740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38741   float result;
38742
38743   arg1 = (Dali::Animation *)jarg1;
38744   {
38745     try {
38746       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38747     } catch (std::out_of_range& e) {
38748       {
38749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (std::exception& e) {
38752       {
38753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761   jresult = result;
38762   return jresult;
38763 }
38764
38765
38766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38767   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38768   bool arg2 ;
38769
38770   arg1 = (Dali::Animation *)jarg1;
38771   arg2 = jarg2 ? true : false;
38772   {
38773     try {
38774       (arg1)->SetLooping(arg2);
38775     } catch (std::out_of_range& e) {
38776       {
38777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38778       };
38779     } catch (std::exception& e) {
38780       {
38781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38782       };
38783     } catch (...) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38786       };
38787     }
38788   }
38789 }
38790
38791
38792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   int arg2 ;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   arg2 = (int)jarg2;
38798   {
38799     try {
38800       (arg1)->SetLoopCount(arg2);
38801     } catch (std::out_of_range& e) {
38802       {
38803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38804       };
38805     } catch (std::exception& e) {
38806       {
38807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38808       };
38809     } catch (...) {
38810       {
38811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38812       };
38813     }
38814   }
38815 }
38816
38817
38818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38819   int jresult ;
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   int result;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   {
38825     try {
38826       result = (int)(arg1)->GetLoopCount();
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38838       };
38839     }
38840   }
38841   jresult = result;
38842   return jresult;
38843 }
38844
38845
38846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38847   int jresult ;
38848   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38849   int result;
38850
38851   arg1 = (Dali::Animation *)jarg1;
38852   {
38853     try {
38854       result = (int)(arg1)->GetCurrentLoop();
38855     } catch (std::out_of_range& e) {
38856       {
38857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38858       };
38859     } catch (std::exception& e) {
38860       {
38861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38862       };
38863     } catch (...) {
38864       {
38865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38866       };
38867     }
38868   }
38869   jresult = result;
38870   return jresult;
38871 }
38872
38873
38874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38875   unsigned int jresult ;
38876   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38877   bool result;
38878
38879   arg1 = (Dali::Animation *)jarg1;
38880   {
38881     try {
38882       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38883     } catch (std::out_of_range& e) {
38884       {
38885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (std::exception& e) {
38888       {
38889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897   jresult = result;
38898   return jresult;
38899 }
38900
38901
38902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38903   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38904   Dali::Animation::EndAction arg2 ;
38905
38906   arg1 = (Dali::Animation *)jarg1;
38907   arg2 = (Dali::Animation::EndAction)jarg2;
38908   {
38909     try {
38910       (arg1)->SetEndAction(arg2);
38911     } catch (std::out_of_range& e) {
38912       {
38913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38914       };
38915     } catch (std::exception& e) {
38916       {
38917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38918       };
38919     } catch (...) {
38920       {
38921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38922       };
38923     }
38924   }
38925 }
38926
38927
38928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38929   int jresult ;
38930   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38931   Dali::Animation::EndAction result;
38932
38933   arg1 = (Dali::Animation *)jarg1;
38934   {
38935     try {
38936       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38937     } catch (std::out_of_range& e) {
38938       {
38939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38940       };
38941     } catch (std::exception& e) {
38942       {
38943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38944       };
38945     } catch (...) {
38946       {
38947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38948       };
38949     }
38950   }
38951   jresult = (int)result;
38952   return jresult;
38953 }
38954
38955
38956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38957   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38958   Dali::Animation::EndAction arg2 ;
38959
38960   arg1 = (Dali::Animation *)jarg1;
38961   arg2 = (Dali::Animation::EndAction)jarg2;
38962   {
38963     try {
38964       (arg1)->SetDisconnectAction(arg2);
38965     } catch (std::out_of_range& e) {
38966       {
38967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38968       };
38969     } catch (std::exception& e) {
38970       {
38971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38972       };
38973     } catch (...) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38976       };
38977     }
38978   }
38979 }
38980
38981
38982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38983   int jresult ;
38984   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38985   Dali::Animation::EndAction result;
38986
38987   arg1 = (Dali::Animation *)jarg1;
38988   {
38989     try {
38990       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38991     } catch (std::out_of_range& e) {
38992       {
38993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38994       };
38995     } catch (std::exception& e) {
38996       {
38997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38998       };
38999     } catch (...) {
39000       {
39001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39002       };
39003     }
39004   }
39005   jresult = (int)result;
39006   return jresult;
39007 }
39008
39009
39010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39011   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39012   Dali::AlphaFunction arg2 ;
39013   Dali::AlphaFunction *argp2 ;
39014
39015   arg1 = (Dali::Animation *)jarg1;
39016   argp2 = (Dali::AlphaFunction *)jarg2;
39017   if (!argp2) {
39018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39019     return ;
39020   }
39021   arg2 = *argp2;
39022   {
39023     try {
39024       (arg1)->SetDefaultAlphaFunction(arg2);
39025     } catch (std::out_of_range& e) {
39026       {
39027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (std::exception& e) {
39030       {
39031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39036       };
39037     }
39038   }
39039 }
39040
39041
39042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39043   void * jresult ;
39044   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39045   Dali::AlphaFunction result;
39046
39047   arg1 = (Dali::Animation *)jarg1;
39048   {
39049     try {
39050       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39051     } catch (std::out_of_range& e) {
39052       {
39053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39054       };
39055     } catch (std::exception& e) {
39056       {
39057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39058       };
39059     } catch (...) {
39060       {
39061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39062       };
39063     }
39064   }
39065   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39066   return jresult;
39067 }
39068
39069
39070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39071   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39072   float arg2 ;
39073
39074   arg1 = (Dali::Animation *)jarg1;
39075   arg2 = (float)jarg2;
39076   {
39077     try {
39078       (arg1)->SetCurrentProgress(arg2);
39079     } catch (std::out_of_range& e) {
39080       {
39081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39082       };
39083     } catch (std::exception& e) {
39084       {
39085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39090       };
39091     }
39092   }
39093 }
39094
39095
39096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39097   float jresult ;
39098   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39099   float result;
39100
39101   arg1 = (Dali::Animation *)jarg1;
39102   {
39103     try {
39104       result = (float)(arg1)->GetCurrentProgress();
39105     } catch (std::out_of_range& e) {
39106       {
39107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (std::exception& e) {
39110       {
39111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119   jresult = result;
39120   return jresult;
39121 }
39122
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39125   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39126   float arg2 ;
39127
39128   arg1 = (Dali::Animation *)jarg1;
39129   arg2 = (float)jarg2;
39130   {
39131     try {
39132       (arg1)->SetSpeedFactor(arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39144       };
39145     }
39146   }
39147 }
39148
39149
39150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39151   float jresult ;
39152   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39153   float result;
39154
39155   arg1 = (Dali::Animation *)jarg1;
39156   {
39157     try {
39158       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39159     } catch (std::out_of_range& e) {
39160       {
39161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39162       };
39163     } catch (std::exception& e) {
39164       {
39165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39166       };
39167     } catch (...) {
39168       {
39169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39170       };
39171     }
39172   }
39173   jresult = result;
39174   return jresult;
39175 }
39176
39177
39178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39179   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39180   Dali::Vector2 *arg2 = 0 ;
39181
39182   arg1 = (Dali::Animation *)jarg1;
39183   arg2 = (Dali::Vector2 *)jarg2;
39184   if (!arg2) {
39185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39186     return ;
39187   }
39188   {
39189     try {
39190       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39191     } catch (std::out_of_range& e) {
39192       {
39193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39194       };
39195     } catch (std::exception& e) {
39196       {
39197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39198       };
39199     } catch (...) {
39200       {
39201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39202       };
39203     }
39204   }
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39209   void * jresult ;
39210   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39211   Dali::Vector2 result;
39212
39213   arg1 = (Dali::Animation *)jarg1;
39214   {
39215     try {
39216       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (...) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39228       };
39229     }
39230   }
39231   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39237   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39238
39239   arg1 = (Dali::Animation *)jarg1;
39240   {
39241     try {
39242       (arg1)->Play();
39243     } catch (std::out_of_range& e) {
39244       {
39245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (std::exception& e) {
39248       {
39249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257 }
39258
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39261   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39262   float arg2 ;
39263
39264   arg1 = (Dali::Animation *)jarg1;
39265   arg2 = (float)jarg2;
39266   {
39267     try {
39268       (arg1)->PlayFrom(arg2);
39269     } catch (std::out_of_range& e) {
39270       {
39271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (std::exception& e) {
39274       {
39275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283 }
39284
39285
39286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39287   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39288
39289   arg1 = (Dali::Animation *)jarg1;
39290   {
39291     try {
39292       (arg1)->Pause();
39293     } catch (std::out_of_range& e) {
39294       {
39295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39296       };
39297     } catch (std::exception& e) {
39298       {
39299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39300       };
39301     } catch (...) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39304       };
39305     }
39306   }
39307 }
39308
39309
39310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39311   int jresult ;
39312   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39313   Dali::Animation::State result;
39314
39315   arg1 = (Dali::Animation *)jarg1;
39316   {
39317     try {
39318       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39319     } catch (std::out_of_range& e) {
39320       {
39321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (std::exception& e) {
39324       {
39325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39326       };
39327     } catch (...) {
39328       {
39329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39330       };
39331     }
39332   }
39333   jresult = (int)result;
39334   return jresult;
39335 }
39336
39337
39338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39339   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39340
39341   arg1 = (Dali::Animation *)jarg1;
39342   {
39343     try {
39344       (arg1)->Stop();
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (...) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39356       };
39357     }
39358   }
39359 }
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39362   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39363
39364   Dali::Animation arg1 = *argp1;
39365   float arg2 = (float)jarg2;
39366
39367   {
39368     try {
39369       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39370     } catch (std::out_of_range& e) {
39371       {
39372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (std::exception& e) {
39375       {
39376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39377       };
39378     } catch (...) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39381       };
39382     }
39383   }
39384 }
39385
39386
39387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39388   float jresult ;
39389   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39390   float result;
39391
39392   Dali::Animation arg1 = *argp1;
39393   {
39394     try {
39395       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
39396     } catch (std::out_of_range& e) {
39397       {
39398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (std::exception& e) {
39401       {
39402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39407       };
39408     }
39409   }
39410   jresult = result;
39411   return jresult;
39412 }
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39415   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39416
39417   arg1 = (Dali::Animation *)jarg1;
39418   {
39419     try {
39420       (arg1)->Clear();
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39432       };
39433     }
39434   }
39435 }
39436
39437
39438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39439   void * jresult ;
39440   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39441   Dali::Animation::AnimationSignalType *result = 0 ;
39442
39443   arg1 = (Dali::Animation *)jarg1;
39444   {
39445     try {
39446       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (...) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39458       };
39459     }
39460   }
39461   jresult = (void *)result;
39462   return jresult;
39463 }
39464
39465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39466   void * jresult ;
39467   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39468   Dali::Animation::AnimationSignalType *result = 0 ;
39469
39470   Dali::Animation arg1 = *argp1;
39471   {
39472     try {
39473       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39474     } catch (std::out_of_range& e) {
39475       {
39476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39477       };
39478     } catch (std::exception& e) {
39479       {
39480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39481       };
39482     } catch (...) {
39483       {
39484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39485       };
39486     }
39487   }
39488   jresult = (void *)result;
39489   return jresult;
39490 }
39491
39492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39493   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39494   SwigValueWrapper< Dali::Property > arg2 ;
39495   Dali::Property::Value arg3 ;
39496   Dali::Property *argp2 ;
39497   Dali::Property::Value *argp3 ;
39498
39499   arg1 = (Dali::Animation *)jarg1;
39500   argp2 = (Dali::Property *)jarg2;
39501   if (!argp2) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39503     return ;
39504   }
39505   arg2 = *argp2;
39506   argp3 = (Dali::Property::Value *)jarg3;
39507   if (!argp3) {
39508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39509     return ;
39510   }
39511   arg3 = *argp3;
39512   {
39513     try {
39514       (arg1)->AnimateBy(arg2,arg3);
39515     } catch (std::out_of_range& e) {
39516       {
39517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39518       };
39519     } catch (std::exception& e) {
39520       {
39521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39522       };
39523     } catch (...) {
39524       {
39525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39526       };
39527     }
39528   }
39529 }
39530
39531
39532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39533   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39534   SwigValueWrapper< Dali::Property > arg2 ;
39535   Dali::Property::Value arg3 ;
39536   Dali::AlphaFunction arg4 ;
39537   Dali::Property *argp2 ;
39538   Dali::Property::Value *argp3 ;
39539   Dali::AlphaFunction *argp4 ;
39540
39541   arg1 = (Dali::Animation *)jarg1;
39542   argp2 = (Dali::Property *)jarg2;
39543   if (!argp2) {
39544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39545     return ;
39546   }
39547   arg2 = *argp2;
39548   argp3 = (Dali::Property::Value *)jarg3;
39549   if (!argp3) {
39550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39551     return ;
39552   }
39553   arg3 = *argp3;
39554   argp4 = (Dali::AlphaFunction *)jarg4;
39555   if (!argp4) {
39556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39557     return ;
39558   }
39559   arg4 = *argp4;
39560   {
39561     try {
39562       (arg1)->AnimateBy(arg2,arg3,arg4);
39563     } catch (std::out_of_range& e) {
39564       {
39565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39566       };
39567     } catch (std::exception& e) {
39568       {
39569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39574       };
39575     }
39576   }
39577 }
39578
39579
39580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39581   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39582   SwigValueWrapper< Dali::Property > arg2 ;
39583   Dali::Property::Value arg3 ;
39584   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39585   Dali::Property *argp2 ;
39586   Dali::Property::Value *argp3 ;
39587   Dali::TimePeriod *argp4 ;
39588
39589   arg1 = (Dali::Animation *)jarg1;
39590   argp2 = (Dali::Property *)jarg2;
39591   if (!argp2) {
39592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39593     return ;
39594   }
39595   arg2 = *argp2;
39596   argp3 = (Dali::Property::Value *)jarg3;
39597   if (!argp3) {
39598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39599     return ;
39600   }
39601   arg3 = *argp3;
39602   argp4 = (Dali::TimePeriod *)jarg4;
39603   if (!argp4) {
39604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39605     return ;
39606   }
39607   arg4 = *argp4;
39608   {
39609     try {
39610       (arg1)->AnimateBy(arg2,arg3,arg4);
39611     } catch (std::out_of_range& e) {
39612       {
39613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39614       };
39615     } catch (std::exception& e) {
39616       {
39617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39618       };
39619     } catch (...) {
39620       {
39621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39622       };
39623     }
39624   }
39625 }
39626
39627
39628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39629   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39630   SwigValueWrapper< Dali::Property > arg2 ;
39631   Dali::Property::Value arg3 ;
39632   Dali::AlphaFunction arg4 ;
39633   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39634   Dali::Property *argp2 ;
39635   Dali::Property::Value *argp3 ;
39636   Dali::AlphaFunction *argp4 ;
39637   Dali::TimePeriod *argp5 ;
39638
39639   arg1 = (Dali::Animation *)jarg1;
39640   argp2 = (Dali::Property *)jarg2;
39641   if (!argp2) {
39642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39643     return ;
39644   }
39645   arg2 = *argp2;
39646   argp3 = (Dali::Property::Value *)jarg3;
39647   if (!argp3) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39649     return ;
39650   }
39651   arg3 = *argp3;
39652   argp4 = (Dali::AlphaFunction *)jarg4;
39653   if (!argp4) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39655     return ;
39656   }
39657   arg4 = *argp4;
39658   argp5 = (Dali::TimePeriod *)jarg5;
39659   if (!argp5) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39661     return ;
39662   }
39663   arg5 = *argp5;
39664   {
39665     try {
39666       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39667     } catch (std::out_of_range& e) {
39668       {
39669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39670       };
39671     } catch (std::exception& e) {
39672       {
39673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39674       };
39675     } catch (...) {
39676       {
39677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39678       };
39679     }
39680   }
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39685   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39686   SwigValueWrapper< Dali::Property > arg2 ;
39687   Dali::Property::Value arg3 ;
39688   Dali::Property *argp2 ;
39689   Dali::Property::Value *argp3 ;
39690
39691   arg1 = (Dali::Animation *)jarg1;
39692   argp2 = (Dali::Property *)jarg2;
39693   if (!argp2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39695     return ;
39696   }
39697   arg2 = *argp2;
39698   argp3 = (Dali::Property::Value *)jarg3;
39699   if (!argp3) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39701     return ;
39702   }
39703   arg3 = *argp3;
39704   {
39705     try {
39706       (arg1)->AnimateTo(arg2,arg3);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721 }
39722
39723
39724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39725   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39726   SwigValueWrapper< Dali::Property > arg2 ;
39727   Dali::Property::Value arg3 ;
39728   Dali::AlphaFunction arg4 ;
39729   Dali::Property *argp2 ;
39730   Dali::Property::Value *argp3 ;
39731   Dali::AlphaFunction *argp4 ;
39732
39733   arg1 = (Dali::Animation *)jarg1;
39734   argp2 = (Dali::Property *)jarg2;
39735   if (!argp2) {
39736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39737     return ;
39738   }
39739   arg2 = *argp2;
39740   argp3 = (Dali::Property::Value *)jarg3;
39741   if (!argp3) {
39742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39743     return ;
39744   }
39745   arg3 = *argp3;
39746   argp4 = (Dali::AlphaFunction *)jarg4;
39747   if (!argp4) {
39748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39749     return ;
39750   }
39751   arg4 = *argp4;
39752   {
39753     try {
39754       (arg1)->AnimateTo(arg2,arg3,arg4);
39755     } catch (std::out_of_range& e) {
39756       {
39757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (std::exception& e) {
39760       {
39761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769 }
39770
39771
39772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39773   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39774   SwigValueWrapper< Dali::Property > arg2 ;
39775   Dali::Property::Value arg3 ;
39776   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39777   Dali::Property *argp2 ;
39778   Dali::Property::Value *argp3 ;
39779   Dali::TimePeriod *argp4 ;
39780
39781   arg1 = (Dali::Animation *)jarg1;
39782   argp2 = (Dali::Property *)jarg2;
39783   if (!argp2) {
39784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39785     return ;
39786   }
39787   arg2 = *argp2;
39788   argp3 = (Dali::Property::Value *)jarg3;
39789   if (!argp3) {
39790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39791     return ;
39792   }
39793   arg3 = *argp3;
39794   argp4 = (Dali::TimePeriod *)jarg4;
39795   if (!argp4) {
39796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39797     return ;
39798   }
39799   arg4 = *argp4;
39800   {
39801     try {
39802       (arg1)->AnimateTo(arg2,arg3,arg4);
39803     } catch (std::out_of_range& e) {
39804       {
39805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39806       };
39807     } catch (std::exception& e) {
39808       {
39809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39810       };
39811     } catch (...) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39814       };
39815     }
39816   }
39817 }
39818
39819
39820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39821   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39822   SwigValueWrapper< Dali::Property > arg2 ;
39823   Dali::Property::Value arg3 ;
39824   Dali::AlphaFunction arg4 ;
39825   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39826   Dali::Property *argp2 ;
39827   Dali::Property::Value *argp3 ;
39828   Dali::AlphaFunction *argp4 ;
39829   Dali::TimePeriod *argp5 ;
39830
39831   arg1 = (Dali::Animation *)jarg1;
39832   argp2 = (Dali::Property *)jarg2;
39833   if (!argp2) {
39834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39835     return ;
39836   }
39837   arg2 = *argp2;
39838   argp3 = (Dali::Property::Value *)jarg3;
39839   if (!argp3) {
39840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39841     return ;
39842   }
39843   arg3 = *argp3;
39844   argp4 = (Dali::AlphaFunction *)jarg4;
39845   if (!argp4) {
39846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39847     return ;
39848   }
39849   arg4 = *argp4;
39850   argp5 = (Dali::TimePeriod *)jarg5;
39851   if (!argp5) {
39852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39853     return ;
39854   }
39855   arg5 = *argp5;
39856   {
39857     try {
39858       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39859     } catch (std::out_of_range& e) {
39860       {
39861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39862       };
39863     } catch (std::exception& e) {
39864       {
39865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39866       };
39867     } catch (...) {
39868       {
39869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39870       };
39871     }
39872   }
39873 }
39874
39875
39876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39877   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39878   SwigValueWrapper< Dali::Property > arg2 ;
39879   Dali::KeyFrames *arg3 = 0 ;
39880   Dali::Property *argp2 ;
39881
39882   arg1 = (Dali::Animation *)jarg1;
39883   argp2 = (Dali::Property *)jarg2;
39884   if (!argp2) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39886     return ;
39887   }
39888   arg2 = *argp2;
39889   arg3 = (Dali::KeyFrames *)jarg3;
39890   if (!arg3) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39892     return ;
39893   }
39894   {
39895     try {
39896       (arg1)->AnimateBetween(arg2,*arg3);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911 }
39912
39913
39914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39915   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39916   SwigValueWrapper< Dali::Property > arg2 ;
39917   Dali::KeyFrames *arg3 = 0 ;
39918   Dali::Animation::Interpolation arg4 ;
39919   Dali::Property *argp2 ;
39920
39921   arg1 = (Dali::Animation *)jarg1;
39922   argp2 = (Dali::Property *)jarg2;
39923   if (!argp2) {
39924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39925     return ;
39926   }
39927   arg2 = *argp2;
39928   arg3 = (Dali::KeyFrames *)jarg3;
39929   if (!arg3) {
39930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39931     return ;
39932   }
39933   arg4 = (Dali::Animation::Interpolation)jarg4;
39934   {
39935     try {
39936       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39937     } catch (std::out_of_range& e) {
39938       {
39939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39940       };
39941     } catch (std::exception& e) {
39942       {
39943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39944       };
39945     } catch (...) {
39946       {
39947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39948       };
39949     }
39950   }
39951 }
39952
39953
39954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39955   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39956   SwigValueWrapper< Dali::Property > arg2 ;
39957   Dali::KeyFrames *arg3 = 0 ;
39958   Dali::AlphaFunction arg4 ;
39959   Dali::Property *argp2 ;
39960   Dali::AlphaFunction *argp4 ;
39961
39962   arg1 = (Dali::Animation *)jarg1;
39963   argp2 = (Dali::Property *)jarg2;
39964   if (!argp2) {
39965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39966     return ;
39967   }
39968   arg2 = *argp2;
39969   arg3 = (Dali::KeyFrames *)jarg3;
39970   if (!arg3) {
39971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39972     return ;
39973   }
39974   argp4 = (Dali::AlphaFunction *)jarg4;
39975   if (!argp4) {
39976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39977     return ;
39978   }
39979   arg4 = *argp4;
39980   {
39981     try {
39982       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39983     } catch (std::out_of_range& e) {
39984       {
39985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (std::exception& e) {
39988       {
39989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997 }
39998
39999
40000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40001   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40002   SwigValueWrapper< Dali::Property > arg2 ;
40003   Dali::KeyFrames *arg3 = 0 ;
40004   Dali::AlphaFunction arg4 ;
40005   Dali::Animation::Interpolation arg5 ;
40006   Dali::Property *argp2 ;
40007   Dali::AlphaFunction *argp4 ;
40008
40009   arg1 = (Dali::Animation *)jarg1;
40010   argp2 = (Dali::Property *)jarg2;
40011   if (!argp2) {
40012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40013     return ;
40014   }
40015   arg2 = *argp2;
40016   arg3 = (Dali::KeyFrames *)jarg3;
40017   if (!arg3) {
40018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40019     return ;
40020   }
40021   argp4 = (Dali::AlphaFunction *)jarg4;
40022   if (!argp4) {
40023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40024     return ;
40025   }
40026   arg4 = *argp4;
40027   arg5 = (Dali::Animation::Interpolation)jarg5;
40028   {
40029     try {
40030       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40031     } catch (std::out_of_range& e) {
40032       {
40033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40034       };
40035     } catch (std::exception& e) {
40036       {
40037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40042       };
40043     }
40044   }
40045 }
40046
40047
40048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40049   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40050   SwigValueWrapper< Dali::Property > arg2 ;
40051   Dali::KeyFrames *arg3 = 0 ;
40052   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40053   Dali::Property *argp2 ;
40054   Dali::TimePeriod *argp4 ;
40055
40056   arg1 = (Dali::Animation *)jarg1;
40057   argp2 = (Dali::Property *)jarg2;
40058   if (!argp2) {
40059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40060     return ;
40061   }
40062   arg2 = *argp2;
40063   arg3 = (Dali::KeyFrames *)jarg3;
40064   if (!arg3) {
40065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40066     return ;
40067   }
40068   argp4 = (Dali::TimePeriod *)jarg4;
40069   if (!argp4) {
40070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40071     return ;
40072   }
40073   arg4 = *argp4;
40074   {
40075     try {
40076       (arg1)->AnimateBetween(arg2,*arg3,arg4);
40077     } catch (std::out_of_range& e) {
40078       {
40079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40080       };
40081     } catch (std::exception& e) {
40082       {
40083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40084       };
40085     } catch (...) {
40086       {
40087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40088       };
40089     }
40090   }
40091 }
40092
40093
40094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40096   SwigValueWrapper< Dali::Property > arg2 ;
40097   Dali::KeyFrames *arg3 = 0 ;
40098   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40099   Dali::Animation::Interpolation arg5 ;
40100   Dali::Property *argp2 ;
40101   Dali::TimePeriod *argp4 ;
40102
40103   arg1 = (Dali::Animation *)jarg1;
40104   argp2 = (Dali::Property *)jarg2;
40105   if (!argp2) {
40106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40107     return ;
40108   }
40109   arg2 = *argp2;
40110   arg3 = (Dali::KeyFrames *)jarg3;
40111   if (!arg3) {
40112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40113     return ;
40114   }
40115   argp4 = (Dali::TimePeriod *)jarg4;
40116   if (!argp4) {
40117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40118     return ;
40119   }
40120   arg4 = *argp4;
40121   arg5 = (Dali::Animation::Interpolation)jarg5;
40122   {
40123     try {
40124       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40125     } catch (std::out_of_range& e) {
40126       {
40127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40128       };
40129     } catch (std::exception& e) {
40130       {
40131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40136       };
40137     }
40138   }
40139 }
40140
40141
40142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40143   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40144   SwigValueWrapper< Dali::Property > arg2 ;
40145   Dali::KeyFrames *arg3 = 0 ;
40146   Dali::AlphaFunction arg4 ;
40147   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40148   Dali::Property *argp2 ;
40149   Dali::AlphaFunction *argp4 ;
40150   Dali::TimePeriod *argp5 ;
40151
40152   arg1 = (Dali::Animation *)jarg1;
40153   argp2 = (Dali::Property *)jarg2;
40154   if (!argp2) {
40155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40156     return ;
40157   }
40158   arg2 = *argp2;
40159   arg3 = (Dali::KeyFrames *)jarg3;
40160   if (!arg3) {
40161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40162     return ;
40163   }
40164   argp4 = (Dali::AlphaFunction *)jarg4;
40165   if (!argp4) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40167     return ;
40168   }
40169   arg4 = *argp4;
40170   argp5 = (Dali::TimePeriod *)jarg5;
40171   if (!argp5) {
40172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40173     return ;
40174   }
40175   arg5 = *argp5;
40176   {
40177     try {
40178       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40186       };
40187     } catch (...) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40190       };
40191     }
40192   }
40193 }
40194
40195
40196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40197   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40198   SwigValueWrapper< Dali::Property > arg2 ;
40199   Dali::KeyFrames *arg3 = 0 ;
40200   Dali::AlphaFunction arg4 ;
40201   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40202   Dali::Animation::Interpolation arg6 ;
40203   Dali::Property *argp2 ;
40204   Dali::AlphaFunction *argp4 ;
40205   Dali::TimePeriod *argp5 ;
40206
40207   arg1 = (Dali::Animation *)jarg1;
40208   argp2 = (Dali::Property *)jarg2;
40209   if (!argp2) {
40210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40211     return ;
40212   }
40213   arg2 = *argp2;
40214   arg3 = (Dali::KeyFrames *)jarg3;
40215   if (!arg3) {
40216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40217     return ;
40218   }
40219   argp4 = (Dali::AlphaFunction *)jarg4;
40220   if (!argp4) {
40221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40222     return ;
40223   }
40224   arg4 = *argp4;
40225   argp5 = (Dali::TimePeriod *)jarg5;
40226   if (!argp5) {
40227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40228     return ;
40229   }
40230   arg5 = *argp5;
40231   arg6 = (Dali::Animation::Interpolation)jarg6;
40232   {
40233     try {
40234       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40246       };
40247     }
40248   }
40249 }
40250
40251
40252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40253   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40254   Dali::Actor arg2 ;
40255   Dali::Path arg3 ;
40256   Dali::Vector3 *arg4 = 0 ;
40257   Dali::Actor *argp2 ;
40258   Dali::Path *argp3 ;
40259
40260   arg1 = (Dali::Animation *)jarg1;
40261   argp2 = (Dali::Actor *)jarg2;
40262   if (!argp2) {
40263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40264     return ;
40265   }
40266   arg2 = *argp2;
40267   argp3 = (Dali::Path *)jarg3;
40268   if (!argp3) {
40269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40270     return ;
40271   }
40272   arg3 = *argp3;
40273   arg4 = (Dali::Vector3 *)jarg4;
40274   if (!arg4) {
40275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40276     return ;
40277   }
40278   {
40279     try {
40280       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40281     } catch (std::out_of_range& e) {
40282       {
40283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40284       };
40285     } catch (std::exception& e) {
40286       {
40287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40288       };
40289     } catch (...) {
40290       {
40291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40292       };
40293     }
40294   }
40295 }
40296
40297
40298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40299   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40300   Dali::Actor arg2 ;
40301   Dali::Path arg3 ;
40302   Dali::Vector3 *arg4 = 0 ;
40303   Dali::AlphaFunction arg5 ;
40304   Dali::Actor *argp2 ;
40305   Dali::Path *argp3 ;
40306   Dali::AlphaFunction *argp5 ;
40307
40308   arg1 = (Dali::Animation *)jarg1;
40309   argp2 = (Dali::Actor *)jarg2;
40310   if (!argp2) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40312     return ;
40313   }
40314   arg2 = *argp2;
40315   argp3 = (Dali::Path *)jarg3;
40316   if (!argp3) {
40317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40318     return ;
40319   }
40320   arg3 = *argp3;
40321   arg4 = (Dali::Vector3 *)jarg4;
40322   if (!arg4) {
40323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40324     return ;
40325   }
40326   argp5 = (Dali::AlphaFunction *)jarg5;
40327   if (!argp5) {
40328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40329     return ;
40330   }
40331   arg5 = *argp5;
40332   {
40333     try {
40334       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40335     } catch (std::out_of_range& e) {
40336       {
40337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40338       };
40339     } catch (std::exception& e) {
40340       {
40341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40342       };
40343     } catch (...) {
40344       {
40345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40346       };
40347     }
40348   }
40349 }
40350
40351
40352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40353   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40354   Dali::Actor arg2 ;
40355   Dali::Path arg3 ;
40356   Dali::Vector3 *arg4 = 0 ;
40357   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40358   Dali::Actor *argp2 ;
40359   Dali::Path *argp3 ;
40360   Dali::TimePeriod *argp5 ;
40361
40362   arg1 = (Dali::Animation *)jarg1;
40363   argp2 = (Dali::Actor *)jarg2;
40364   if (!argp2) {
40365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40366     return ;
40367   }
40368   arg2 = *argp2;
40369   argp3 = (Dali::Path *)jarg3;
40370   if (!argp3) {
40371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40372     return ;
40373   }
40374   arg3 = *argp3;
40375   arg4 = (Dali::Vector3 *)jarg4;
40376   if (!arg4) {
40377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40378     return ;
40379   }
40380   argp5 = (Dali::TimePeriod *)jarg5;
40381   if (!argp5) {
40382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40383     return ;
40384   }
40385   arg5 = *argp5;
40386   {
40387     try {
40388       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40389     } catch (std::out_of_range& e) {
40390       {
40391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40392       };
40393     } catch (std::exception& e) {
40394       {
40395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40396       };
40397     } catch (...) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40400       };
40401     }
40402   }
40403 }
40404
40405
40406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40407   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40408   Dali::Actor arg2 ;
40409   Dali::Path arg3 ;
40410   Dali::Vector3 *arg4 = 0 ;
40411   Dali::AlphaFunction arg5 ;
40412   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40413   Dali::Actor *argp2 ;
40414   Dali::Path *argp3 ;
40415   Dali::AlphaFunction *argp5 ;
40416   Dali::TimePeriod *argp6 ;
40417
40418   arg1 = (Dali::Animation *)jarg1;
40419   argp2 = (Dali::Actor *)jarg2;
40420   if (!argp2) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40422     return ;
40423   }
40424   arg2 = *argp2;
40425   argp3 = (Dali::Path *)jarg3;
40426   if (!argp3) {
40427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40428     return ;
40429   }
40430   arg3 = *argp3;
40431   arg4 = (Dali::Vector3 *)jarg4;
40432   if (!arg4) {
40433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40434     return ;
40435   }
40436   argp5 = (Dali::AlphaFunction *)jarg5;
40437   if (!argp5) {
40438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40439     return ;
40440   }
40441   arg5 = *argp5;
40442   argp6 = (Dali::TimePeriod *)jarg6;
40443   if (!argp6) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40445     return ;
40446   }
40447   arg6 = *argp6;
40448   {
40449     try {
40450       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40451     } catch (std::out_of_range& e) {
40452       {
40453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40454       };
40455     } catch (std::exception& e) {
40456       {
40457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (...) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40462       };
40463     }
40464   }
40465 }
40466
40467
40468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40469   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40470   Dali::Actor arg2 ;
40471   float arg3 ;
40472   Dali::Actor *argp2 ;
40473
40474   arg1 = (Dali::Animation *)jarg1;
40475   argp2 = (Dali::Actor *)jarg2;
40476   if (!argp2) {
40477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40478     return ;
40479   }
40480   arg2 = *argp2;
40481   arg3 = (float)jarg3;
40482   {
40483     try {
40484       (arg1)->Show(arg2,arg3);
40485     } catch (std::out_of_range& e) {
40486       {
40487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40488       };
40489     } catch (std::exception& e) {
40490       {
40491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (...) {
40494       {
40495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40496       };
40497     }
40498   }
40499 }
40500
40501
40502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40503   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40504   Dali::Actor arg2 ;
40505   float arg3 ;
40506   Dali::Actor *argp2 ;
40507
40508   arg1 = (Dali::Animation *)jarg1;
40509   argp2 = (Dali::Actor *)jarg2;
40510   if (!argp2) {
40511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40512     return ;
40513   }
40514   arg2 = *argp2;
40515   arg3 = (float)jarg3;
40516   {
40517     try {
40518       (arg1)->Hide(arg2,arg3);
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40526       };
40527     } catch (...) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40530       };
40531     }
40532   }
40533 }
40534
40535
40536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40537   int jresult ;
40538   int result;
40539
40540   result = (int)Dali::LinearConstrainer::Property::VALUE;
40541   jresult = (int)result;
40542   return jresult;
40543 }
40544
40545
40546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40547   int jresult ;
40548   int result;
40549
40550   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40551   jresult = (int)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40557   void * jresult ;
40558   Dali::LinearConstrainer::Property *result = 0 ;
40559
40560   {
40561     try {
40562       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577   jresult = (void *)result;
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40583   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40584
40585   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40586   {
40587     try {
40588       delete arg1;
40589     } catch (std::out_of_range& e) {
40590       {
40591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40592       };
40593     } catch (std::exception& e) {
40594       {
40595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40596       };
40597     } catch (...) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40600       };
40601     }
40602   }
40603 }
40604
40605
40606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40607   void * jresult ;
40608   Dali::LinearConstrainer result;
40609
40610   {
40611     try {
40612       result = Dali::LinearConstrainer::New();
40613     } catch (std::out_of_range& e) {
40614       {
40615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40616       };
40617     } catch (std::exception& e) {
40618       {
40619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40620       };
40621     } catch (...) {
40622       {
40623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40624       };
40625     }
40626   }
40627   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40628   return jresult;
40629 }
40630
40631
40632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40633   void * jresult ;
40634   Dali::BaseHandle arg1 ;
40635   Dali::BaseHandle *argp1 ;
40636   Dali::LinearConstrainer result;
40637
40638   argp1 = (Dali::BaseHandle *)jarg1;
40639   if (!argp1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40641     return 0;
40642   }
40643   arg1 = *argp1;
40644   {
40645     try {
40646       result = Dali::LinearConstrainer::DownCast(arg1);
40647     } catch (std::out_of_range& e) {
40648       {
40649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40650       };
40651     } catch (std::exception& e) {
40652       {
40653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40654       };
40655     } catch (...) {
40656       {
40657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40658       };
40659     }
40660   }
40661   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40662   return jresult;
40663 }
40664
40665
40666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40667   void * jresult ;
40668   Dali::LinearConstrainer *result = 0 ;
40669
40670   {
40671     try {
40672       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40673     } catch (std::out_of_range& e) {
40674       {
40675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40676       };
40677     } catch (std::exception& e) {
40678       {
40679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40680       };
40681     } catch (...) {
40682       {
40683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40684       };
40685     }
40686   }
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40693   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40694
40695   arg1 = (Dali::LinearConstrainer *)jarg1;
40696   {
40697     try {
40698       delete arg1;
40699     } catch (std::out_of_range& e) {
40700       {
40701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40702       };
40703     } catch (std::exception& e) {
40704       {
40705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40706       };
40707     } catch (...) {
40708       {
40709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40710       };
40711     }
40712   }
40713 }
40714
40715
40716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40717   void * jresult ;
40718   Dali::LinearConstrainer *arg1 = 0 ;
40719   Dali::LinearConstrainer *result = 0 ;
40720
40721   arg1 = (Dali::LinearConstrainer *)jarg1;
40722   if (!arg1) {
40723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40724     return 0;
40725   }
40726   {
40727     try {
40728       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40729     } catch (std::out_of_range& e) {
40730       {
40731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40732       };
40733     } catch (std::exception& e) {
40734       {
40735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40740       };
40741     }
40742   }
40743   jresult = (void *)result;
40744   return jresult;
40745 }
40746
40747
40748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40749   void * jresult ;
40750   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40751   Dali::LinearConstrainer *arg2 = 0 ;
40752   Dali::LinearConstrainer *result = 0 ;
40753
40754   arg1 = (Dali::LinearConstrainer *)jarg1;
40755   arg2 = (Dali::LinearConstrainer *)jarg2;
40756   if (!arg2) {
40757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40758     return 0;
40759   }
40760   {
40761     try {
40762       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40774       };
40775     }
40776   }
40777   jresult = (void *)result;
40778   return jresult;
40779 }
40780
40781
40782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40783   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40784   SwigValueWrapper< Dali::Property > arg2 ;
40785   SwigValueWrapper< Dali::Property > arg3 ;
40786   Dali::Vector2 *arg4 = 0 ;
40787   Dali::Vector2 *arg5 = 0 ;
40788   Dali::Property *argp2 ;
40789   Dali::Property *argp3 ;
40790
40791   arg1 = (Dali::LinearConstrainer *)jarg1;
40792   argp2 = (Dali::Property *)jarg2;
40793   if (!argp2) {
40794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40795     return ;
40796   }
40797   arg2 = *argp2;
40798   argp3 = (Dali::Property *)jarg3;
40799   if (!argp3) {
40800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40801     return ;
40802   }
40803   arg3 = *argp3;
40804   arg4 = (Dali::Vector2 *)jarg4;
40805   if (!arg4) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40807     return ;
40808   }
40809   arg5 = (Dali::Vector2 *)jarg5;
40810   if (!arg5) {
40811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40812     return ;
40813   }
40814   {
40815     try {
40816       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40817     } catch (std::out_of_range& e) {
40818       {
40819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40820       };
40821     } catch (std::exception& e) {
40822       {
40823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40824       };
40825     } catch (...) {
40826       {
40827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40828       };
40829     }
40830   }
40831 }
40832
40833
40834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40835   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40836   SwigValueWrapper< Dali::Property > arg2 ;
40837   SwigValueWrapper< Dali::Property > arg3 ;
40838   Dali::Vector2 *arg4 = 0 ;
40839   Dali::Property *argp2 ;
40840   Dali::Property *argp3 ;
40841
40842   arg1 = (Dali::LinearConstrainer *)jarg1;
40843   argp2 = (Dali::Property *)jarg2;
40844   if (!argp2) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40846     return ;
40847   }
40848   arg2 = *argp2;
40849   argp3 = (Dali::Property *)jarg3;
40850   if (!argp3) {
40851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40852     return ;
40853   }
40854   arg3 = *argp3;
40855   arg4 = (Dali::Vector2 *)jarg4;
40856   if (!arg4) {
40857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40858     return ;
40859   }
40860   {
40861     try {
40862       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (...) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40874       };
40875     }
40876   }
40877 }
40878
40879
40880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40881   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40882   Dali::Handle *arg2 = 0 ;
40883
40884   arg1 = (Dali::LinearConstrainer *)jarg1;
40885   arg2 = (Dali::Handle *)jarg2;
40886   if (!arg2) {
40887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40888     return ;
40889   }
40890   {
40891     try {
40892       (arg1)->Remove(*arg2);
40893     } catch (std::out_of_range& e) {
40894       {
40895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (std::exception& e) {
40898       {
40899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40904       };
40905     }
40906   }
40907 }
40908
40909
40910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40911   int jresult ;
40912   int result;
40913
40914   result = (int)Dali::PathConstrainer::Property::FORWARD;
40915   jresult = (int)result;
40916   return jresult;
40917 }
40918
40919
40920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40921   int jresult ;
40922   int result;
40923
40924   result = (int)Dali::PathConstrainer::Property::POINTS;
40925   jresult = (int)result;
40926   return jresult;
40927 }
40928
40929
40930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40931   int jresult ;
40932   int result;
40933
40934   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40935   jresult = (int)result;
40936   return jresult;
40937 }
40938
40939
40940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40941   void * jresult ;
40942   Dali::PathConstrainer::Property *result = 0 ;
40943
40944   {
40945     try {
40946       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40947     } catch (std::out_of_range& e) {
40948       {
40949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40950       };
40951     } catch (std::exception& e) {
40952       {
40953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (...) {
40956       {
40957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40958       };
40959     }
40960   }
40961   jresult = (void *)result;
40962   return jresult;
40963 }
40964
40965
40966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40967   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40968
40969   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40970   {
40971     try {
40972       delete arg1;
40973     } catch (std::out_of_range& e) {
40974       {
40975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40976       };
40977     } catch (std::exception& e) {
40978       {
40979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (...) {
40982       {
40983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40984       };
40985     }
40986   }
40987 }
40988
40989
40990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40991   void * jresult ;
40992   Dali::PathConstrainer result;
40993
40994   {
40995     try {
40996       result = Dali::PathConstrainer::New();
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41004       };
41005     } catch (...) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41008       };
41009     }
41010   }
41011   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41012   return jresult;
41013 }
41014
41015
41016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
41017   void * jresult ;
41018   Dali::BaseHandle arg1 ;
41019   Dali::BaseHandle *argp1 ;
41020   Dali::PathConstrainer result;
41021
41022   argp1 = (Dali::BaseHandle *)jarg1;
41023   if (!argp1) {
41024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41025     return 0;
41026   }
41027   arg1 = *argp1;
41028   {
41029     try {
41030       result = Dali::PathConstrainer::DownCast(arg1);
41031     } catch (std::out_of_range& e) {
41032       {
41033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (std::exception& e) {
41036       {
41037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
41051   void * jresult ;
41052   Dali::PathConstrainer *result = 0 ;
41053
41054   {
41055     try {
41056       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
41057     } catch (std::out_of_range& e) {
41058       {
41059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41060       };
41061     } catch (std::exception& e) {
41062       {
41063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41064       };
41065     } catch (...) {
41066       {
41067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41068       };
41069     }
41070   }
41071   jresult = (void *)result;
41072   return jresult;
41073 }
41074
41075
41076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
41077   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41078
41079   arg1 = (Dali::PathConstrainer *)jarg1;
41080   {
41081     try {
41082       delete arg1;
41083     } catch (std::out_of_range& e) {
41084       {
41085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41086       };
41087     } catch (std::exception& e) {
41088       {
41089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (...) {
41092       {
41093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41094       };
41095     }
41096   }
41097 }
41098
41099
41100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41101   void * jresult ;
41102   Dali::PathConstrainer *arg1 = 0 ;
41103   Dali::PathConstrainer *result = 0 ;
41104
41105   arg1 = (Dali::PathConstrainer *)jarg1;
41106   if (!arg1) {
41107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41108     return 0;
41109   }
41110   {
41111     try {
41112       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (...) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41124       };
41125     }
41126   }
41127   jresult = (void *)result;
41128   return jresult;
41129 }
41130
41131
41132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41133   void * jresult ;
41134   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41135   Dali::PathConstrainer *arg2 = 0 ;
41136   Dali::PathConstrainer *result = 0 ;
41137
41138   arg1 = (Dali::PathConstrainer *)jarg1;
41139   arg2 = (Dali::PathConstrainer *)jarg2;
41140   if (!arg2) {
41141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41142     return 0;
41143   }
41144   {
41145     try {
41146       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41147     } catch (std::out_of_range& e) {
41148       {
41149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (std::exception& e) {
41152       {
41153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41158       };
41159     }
41160   }
41161   jresult = (void *)result;
41162   return jresult;
41163 }
41164
41165
41166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41167   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41168   SwigValueWrapper< Dali::Property > arg2 ;
41169   SwigValueWrapper< Dali::Property > arg3 ;
41170   Dali::Vector2 *arg4 = 0 ;
41171   Dali::Vector2 *arg5 = 0 ;
41172   Dali::Property *argp2 ;
41173   Dali::Property *argp3 ;
41174
41175   arg1 = (Dali::PathConstrainer *)jarg1;
41176   argp2 = (Dali::Property *)jarg2;
41177   if (!argp2) {
41178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41179     return ;
41180   }
41181   arg2 = *argp2;
41182   argp3 = (Dali::Property *)jarg3;
41183   if (!argp3) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41185     return ;
41186   }
41187   arg3 = *argp3;
41188   arg4 = (Dali::Vector2 *)jarg4;
41189   if (!arg4) {
41190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41191     return ;
41192   }
41193   arg5 = (Dali::Vector2 *)jarg5;
41194   if (!arg5) {
41195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41196     return ;
41197   }
41198   {
41199     try {
41200       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41201     } catch (std::out_of_range& e) {
41202       {
41203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41204       };
41205     } catch (std::exception& e) {
41206       {
41207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41212       };
41213     }
41214   }
41215 }
41216
41217
41218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41219   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41220   SwigValueWrapper< Dali::Property > arg2 ;
41221   SwigValueWrapper< Dali::Property > arg3 ;
41222   Dali::Vector2 *arg4 = 0 ;
41223   Dali::Property *argp2 ;
41224   Dali::Property *argp3 ;
41225
41226   arg1 = (Dali::PathConstrainer *)jarg1;
41227   argp2 = (Dali::Property *)jarg2;
41228   if (!argp2) {
41229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41230     return ;
41231   }
41232   arg2 = *argp2;
41233   argp3 = (Dali::Property *)jarg3;
41234   if (!argp3) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41236     return ;
41237   }
41238   arg3 = *argp3;
41239   arg4 = (Dali::Vector2 *)jarg4;
41240   if (!arg4) {
41241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41242     return ;
41243   }
41244   {
41245     try {
41246       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41247     } catch (std::out_of_range& e) {
41248       {
41249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41250       };
41251     } catch (std::exception& e) {
41252       {
41253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41254       };
41255     } catch (...) {
41256       {
41257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41258       };
41259     }
41260   }
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41265   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41266   Dali::Handle *arg2 = 0 ;
41267
41268   arg1 = (Dali::PathConstrainer *)jarg1;
41269   arg2 = (Dali::Handle *)jarg2;
41270   if (!arg2) {
41271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41272     return ;
41273   }
41274   {
41275     try {
41276       (arg1)->Remove(*arg2);
41277     } catch (std::out_of_range& e) {
41278       {
41279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41280       };
41281     } catch (std::exception& e) {
41282       {
41283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41284       };
41285     } catch (...) {
41286       {
41287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41288       };
41289     }
41290   }
41291 }
41292
41293
41294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41295   int jresult ;
41296   Dali::FittingMode::Type result;
41297
41298   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41299   jresult = (int)result;
41300   return jresult;
41301 }
41302
41303
41304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41305   int jresult ;
41306   Dali::SamplingMode::Type result;
41307
41308   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41309   jresult = (int)result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41315   void * jresult ;
41316   Dali::BufferImage *result = 0 ;
41317
41318   {
41319     try {
41320       result = (Dali::BufferImage *)new Dali::BufferImage();
41321     } catch (std::out_of_range& e) {
41322       {
41323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41324       };
41325     } catch (std::exception& e) {
41326       {
41327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41328       };
41329     } catch (...) {
41330       {
41331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41332       };
41333     }
41334   }
41335   jresult = (void *)result;
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41341   void * jresult ;
41342   unsigned int arg1 ;
41343   unsigned int arg2 ;
41344   Dali::Pixel::Format arg3 ;
41345   Dali::BufferImage result;
41346
41347   arg1 = (unsigned int)jarg1;
41348   arg2 = (unsigned int)jarg2;
41349   arg3 = (Dali::Pixel::Format)jarg3;
41350   {
41351     try {
41352       result = Dali::BufferImage::New(arg1,arg2,arg3);
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (...) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41364       };
41365     }
41366   }
41367   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41373   void * jresult ;
41374   unsigned int arg1 ;
41375   unsigned int arg2 ;
41376   Dali::BufferImage result;
41377
41378   arg1 = (unsigned int)jarg1;
41379   arg2 = (unsigned int)jarg2;
41380   {
41381     try {
41382       result = Dali::BufferImage::New(arg1,arg2);
41383     } catch (std::out_of_range& e) {
41384       {
41385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (std::exception& e) {
41388       {
41389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41403   void * jresult ;
41404   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41405   unsigned int arg2 ;
41406   unsigned int arg3 ;
41407   Dali::Pixel::Format arg4 ;
41408   unsigned int arg5 ;
41409   Dali::BufferImage result;
41410
41411   arg1 = jarg1;
41412   arg2 = (unsigned int)jarg2;
41413   arg3 = (unsigned int)jarg3;
41414   arg4 = (Dali::Pixel::Format)jarg4;
41415   arg5 = (unsigned int)jarg5;
41416   {
41417     try {
41418       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41419     } catch (std::out_of_range& e) {
41420       {
41421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41422       };
41423     } catch (std::exception& e) {
41424       {
41425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (...) {
41428       {
41429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41430       };
41431     }
41432   }
41433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41434
41435
41436   return jresult;
41437 }
41438
41439
41440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41441   void * jresult ;
41442   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41443   unsigned int arg2 ;
41444   unsigned int arg3 ;
41445   Dali::Pixel::Format arg4 ;
41446   Dali::BufferImage result;
41447
41448   arg1 = jarg1;
41449   arg2 = (unsigned int)jarg2;
41450   arg3 = (unsigned int)jarg3;
41451   arg4 = (Dali::Pixel::Format)jarg4;
41452   {
41453     try {
41454       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41455     } catch (std::out_of_range& e) {
41456       {
41457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41458       };
41459     } catch (std::exception& e) {
41460       {
41461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41462       };
41463     } catch (...) {
41464       {
41465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41466       };
41467     }
41468   }
41469   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41470
41471
41472   return jresult;
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41477   void * jresult ;
41478   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41479   unsigned int arg2 ;
41480   unsigned int arg3 ;
41481   Dali::BufferImage result;
41482
41483   arg1 = jarg1;
41484   arg2 = (unsigned int)jarg2;
41485   arg3 = (unsigned int)jarg3;
41486   {
41487     try {
41488       result = Dali::BufferImage::New(arg1,arg2,arg3);
41489     } catch (std::out_of_range& e) {
41490       {
41491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41492       };
41493     } catch (std::exception& e) {
41494       {
41495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41496       };
41497     } catch (...) {
41498       {
41499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41500       };
41501     }
41502   }
41503   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41504
41505
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41511   void * jresult ;
41512   Dali::BaseHandle arg1 ;
41513   Dali::BaseHandle *argp1 ;
41514   Dali::BufferImage result;
41515
41516   argp1 = (Dali::BaseHandle *)jarg1;
41517   if (!argp1) {
41518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41519     return 0;
41520   }
41521   arg1 = *argp1;
41522   {
41523     try {
41524       result = Dali::BufferImage::DownCast(arg1);
41525     } catch (std::out_of_range& e) {
41526       {
41527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (std::exception& e) {
41530       {
41531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41532       };
41533     } catch (...) {
41534       {
41535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41536       };
41537     }
41538   }
41539   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41540   return jresult;
41541 }
41542
41543
41544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41545   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41546
41547   arg1 = (Dali::BufferImage *)jarg1;
41548   {
41549     try {
41550       delete arg1;
41551     } catch (std::out_of_range& e) {
41552       {
41553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41554       };
41555     } catch (std::exception& e) {
41556       {
41557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41562       };
41563     }
41564   }
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41569   void * jresult ;
41570   Dali::BufferImage *arg1 = 0 ;
41571   Dali::BufferImage *result = 0 ;
41572
41573   arg1 = (Dali::BufferImage *)jarg1;
41574   if (!arg1) {
41575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41576     return 0;
41577   }
41578   {
41579     try {
41580       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41581     } catch (std::out_of_range& e) {
41582       {
41583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (std::exception& e) {
41586       {
41587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41588       };
41589     } catch (...) {
41590       {
41591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41592       };
41593     }
41594   }
41595   jresult = (void *)result;
41596   return jresult;
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41601   void * jresult ;
41602   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41603   Dali::BufferImage *arg2 = 0 ;
41604   Dali::BufferImage *result = 0 ;
41605
41606   arg1 = (Dali::BufferImage *)jarg1;
41607   arg2 = (Dali::BufferImage *)jarg2;
41608   if (!arg2) {
41609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41610     return 0;
41611   }
41612   {
41613     try {
41614       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41615     } catch (std::out_of_range& e) {
41616       {
41617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41618       };
41619     } catch (std::exception& e) {
41620       {
41621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41622       };
41623     } catch (...) {
41624       {
41625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41626       };
41627     }
41628   }
41629   jresult = (void *)result;
41630   return jresult;
41631 }
41632
41633
41634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41635   void * jresult ;
41636   Dali::BufferImage result;
41637
41638   {
41639     try {
41640       result = Dali::BufferImage::WHITE();
41641     } catch (std::out_of_range& e) {
41642       {
41643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (std::exception& e) {
41646       {
41647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41652       };
41653     }
41654   }
41655   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41661   void * jresult ;
41662   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41663   Dali::PixelBuffer *result = 0 ;
41664
41665   arg1 = (Dali::BufferImage *)jarg1;
41666   {
41667     try {
41668       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41669     } catch (std::out_of_range& e) {
41670       {
41671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (std::exception& e) {
41674       {
41675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (...) {
41678       {
41679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41680       };
41681     }
41682   }
41683   jresult = (void *)result;
41684   return jresult;
41685 }
41686
41687
41688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41689   unsigned int jresult ;
41690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41691   unsigned int result;
41692
41693   arg1 = (Dali::BufferImage *)jarg1;
41694   {
41695     try {
41696       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41697     } catch (std::out_of_range& e) {
41698       {
41699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (std::exception& e) {
41702       {
41703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41704       };
41705     } catch (...) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41708       };
41709     }
41710   }
41711   jresult = result;
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41717   unsigned int jresult ;
41718   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41719   unsigned int result;
41720
41721   arg1 = (Dali::BufferImage *)jarg1;
41722   {
41723     try {
41724       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (...) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41736       };
41737     }
41738   }
41739   jresult = result;
41740   return jresult;
41741 }
41742
41743
41744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41745   int jresult ;
41746   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41747   Dali::Pixel::Format result;
41748
41749   arg1 = (Dali::BufferImage *)jarg1;
41750   {
41751     try {
41752       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767   jresult = (int)result;
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41773   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41774
41775   arg1 = (Dali::BufferImage *)jarg1;
41776   {
41777     try {
41778       (arg1)->Update();
41779     } catch (std::out_of_range& e) {
41780       {
41781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41782       };
41783     } catch (std::exception& e) {
41784       {
41785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41786       };
41787     } catch (...) {
41788       {
41789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41790       };
41791     }
41792   }
41793 }
41794
41795
41796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41797   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41798   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41799   Dali::RectArea *argp2 ;
41800
41801   arg1 = (Dali::BufferImage *)jarg1;
41802   argp2 = (Dali::RectArea *)jarg2;
41803   if (!argp2) {
41804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41805     return ;
41806   }
41807   arg2 = *argp2;
41808   {
41809     try {
41810       (arg1)->Update(arg2);
41811     } catch (std::out_of_range& e) {
41812       {
41813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41814       };
41815     } catch (std::exception& e) {
41816       {
41817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41818       };
41819     } catch (...) {
41820       {
41821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41822       };
41823     }
41824   }
41825 }
41826
41827
41828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41829   unsigned int jresult ;
41830   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41831   bool result;
41832
41833   arg1 = (Dali::BufferImage *)jarg1;
41834   {
41835     try {
41836       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (...) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41848       };
41849     }
41850   }
41851   jresult = result;
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41857   void * jresult ;
41858   Dali::EncodedBufferImage *result = 0 ;
41859
41860   {
41861     try {
41862       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41863     } catch (std::out_of_range& e) {
41864       {
41865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (std::exception& e) {
41868       {
41869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41883   void * jresult ;
41884   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41885   std::size_t arg2 ;
41886   Dali::EncodedBufferImage result;
41887
41888   arg1 = (uint8_t *)jarg1;
41889   arg2 = (std::size_t)jarg2;
41890   {
41891     try {
41892       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (...) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41904       };
41905     }
41906   }
41907   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41913   void * jresult ;
41914   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41915   std::size_t arg2 ;
41916   Dali::ImageDimensions arg3 ;
41917   Dali::FittingMode::Type arg4 ;
41918   Dali::SamplingMode::Type arg5 ;
41919   bool arg6 ;
41920   Dali::ImageDimensions *argp3 ;
41921   Dali::EncodedBufferImage result;
41922
41923   arg1 = (uint8_t *)jarg1;
41924   arg2 = (std::size_t)jarg2;
41925   argp3 = (Dali::ImageDimensions *)jarg3;
41926   if (!argp3) {
41927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41928     return 0;
41929   }
41930   arg3 = *argp3;
41931   arg4 = (Dali::FittingMode::Type)jarg4;
41932   arg5 = (Dali::SamplingMode::Type)jarg5;
41933   arg6 = jarg6 ? true : false;
41934   {
41935     try {
41936       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41937     } catch (std::out_of_range& e) {
41938       {
41939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (std::exception& e) {
41942       {
41943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (...) {
41946       {
41947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41948       };
41949     }
41950   }
41951   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41952   return jresult;
41953 }
41954
41955
41956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41957   void * jresult ;
41958   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41959   std::size_t arg2 ;
41960   Dali::ImageDimensions arg3 ;
41961   Dali::FittingMode::Type arg4 ;
41962   Dali::SamplingMode::Type arg5 ;
41963   Dali::ImageDimensions *argp3 ;
41964   Dali::EncodedBufferImage result;
41965
41966   arg1 = (uint8_t *)jarg1;
41967   arg2 = (std::size_t)jarg2;
41968   argp3 = (Dali::ImageDimensions *)jarg3;
41969   if (!argp3) {
41970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41971     return 0;
41972   }
41973   arg3 = *argp3;
41974   arg4 = (Dali::FittingMode::Type)jarg4;
41975   arg5 = (Dali::SamplingMode::Type)jarg5;
41976   {
41977     try {
41978       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41979     } catch (std::out_of_range& e) {
41980       {
41981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41982       };
41983     } catch (std::exception& e) {
41984       {
41985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41986       };
41987     } catch (...) {
41988       {
41989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41990       };
41991     }
41992   }
41993   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41994   return jresult;
41995 }
41996
41997
41998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41999   void * jresult ;
42000   Dali::BaseHandle arg1 ;
42001   Dali::BaseHandle *argp1 ;
42002   Dali::EncodedBufferImage result;
42003
42004   argp1 = (Dali::BaseHandle *)jarg1;
42005   if (!argp1) {
42006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42007     return 0;
42008   }
42009   arg1 = *argp1;
42010   {
42011     try {
42012       result = Dali::EncodedBufferImage::DownCast(arg1);
42013     } catch (std::out_of_range& e) {
42014       {
42015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (std::exception& e) {
42018       {
42019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
42033   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42034
42035   arg1 = (Dali::EncodedBufferImage *)jarg1;
42036   {
42037     try {
42038       delete arg1;
42039     } catch (std::out_of_range& e) {
42040       {
42041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42042       };
42043     } catch (std::exception& e) {
42044       {
42045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42046       };
42047     } catch (...) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42050       };
42051     }
42052   }
42053 }
42054
42055
42056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
42057   void * jresult ;
42058   Dali::EncodedBufferImage *arg1 = 0 ;
42059   Dali::EncodedBufferImage *result = 0 ;
42060
42061   arg1 = (Dali::EncodedBufferImage *)jarg1;
42062   if (!arg1) {
42063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42064     return 0;
42065   }
42066   {
42067     try {
42068       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
42069     } catch (std::out_of_range& e) {
42070       {
42071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42072       };
42073     } catch (std::exception& e) {
42074       {
42075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42080       };
42081     }
42082   }
42083   jresult = (void *)result;
42084   return jresult;
42085 }
42086
42087
42088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42089   void * jresult ;
42090   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42091   Dali::EncodedBufferImage *arg2 = 0 ;
42092   Dali::EncodedBufferImage *result = 0 ;
42093
42094   arg1 = (Dali::EncodedBufferImage *)jarg1;
42095   arg2 = (Dali::EncodedBufferImage *)jarg2;
42096   if (!arg2) {
42097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42098     return 0;
42099   }
42100   {
42101     try {
42102       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42103     } catch (std::out_of_range& e) {
42104       {
42105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42106       };
42107     } catch (std::exception& e) {
42108       {
42109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42110       };
42111     } catch (...) {
42112       {
42113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42114       };
42115     }
42116   }
42117   jresult = (void *)result;
42118   return jresult;
42119 }
42120
42121
42122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42123   void * jresult ;
42124   Dali::NativeImage *result = 0 ;
42125
42126   {
42127     try {
42128       result = (Dali::NativeImage *)new Dali::NativeImage();
42129     } catch (std::out_of_range& e) {
42130       {
42131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (std::exception& e) {
42134       {
42135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42136       };
42137     } catch (...) {
42138       {
42139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42140       };
42141     }
42142   }
42143   jresult = (void *)result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42149   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42150
42151   arg1 = (Dali::NativeImage *)jarg1;
42152   {
42153     try {
42154       delete arg1;
42155     } catch (std::out_of_range& e) {
42156       {
42157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42158       };
42159     } catch (std::exception& e) {
42160       {
42161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42162       };
42163     } catch (...) {
42164       {
42165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42166       };
42167     }
42168   }
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42173   void * jresult ;
42174   Dali::NativeImage *arg1 = 0 ;
42175   Dali::NativeImage *result = 0 ;
42176
42177   arg1 = (Dali::NativeImage *)jarg1;
42178   if (!arg1) {
42179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42180     return 0;
42181   }
42182   {
42183     try {
42184       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42185     } catch (std::out_of_range& e) {
42186       {
42187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (std::exception& e) {
42190       {
42191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199   jresult = (void *)result;
42200   return jresult;
42201 }
42202
42203
42204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42205   void * jresult ;
42206   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42207   Dali::NativeImage *arg2 = 0 ;
42208   Dali::NativeImage *result = 0 ;
42209
42210   arg1 = (Dali::NativeImage *)jarg1;
42211   arg2 = (Dali::NativeImage *)jarg2;
42212   if (!arg2) {
42213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42214     return 0;
42215   }
42216   {
42217     try {
42218       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42219     } catch (std::out_of_range& e) {
42220       {
42221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42222       };
42223     } catch (std::exception& e) {
42224       {
42225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42226       };
42227     } catch (...) {
42228       {
42229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42230       };
42231     }
42232   }
42233   jresult = (void *)result;
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42239   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42240
42241   arg1 = (Dali::NativeImage *)jarg1;
42242   {
42243     try {
42244       (arg1)->CreateGlTexture();
42245     } catch (std::out_of_range& e) {
42246       {
42247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42248       };
42249     } catch (std::exception& e) {
42250       {
42251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42252       };
42253     } catch (...) {
42254       {
42255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42256       };
42257     }
42258   }
42259 }
42260
42261
42262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42263   void * jresult ;
42264   NativeImageInterface *arg1 = 0 ;
42265   Dali::NativeImage result;
42266
42267   arg1 = (NativeImageInterface *)jarg1;
42268   if (!arg1) {
42269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42270     return 0;
42271   }
42272   {
42273     try {
42274       result = Dali::NativeImage::New(*arg1);
42275     } catch (std::out_of_range& e) {
42276       {
42277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42278       };
42279     } catch (std::exception& e) {
42280       {
42281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (...) {
42284       {
42285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42286       };
42287     }
42288   }
42289   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42290   return jresult;
42291 }
42292
42293
42294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42295   void * jresult ;
42296   Dali::BaseHandle arg1 ;
42297   Dali::BaseHandle *argp1 ;
42298   Dali::NativeImage result;
42299
42300   argp1 = (Dali::BaseHandle *)jarg1;
42301   if (!argp1) {
42302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42303     return 0;
42304   }
42305   arg1 = *argp1;
42306   {
42307     try {
42308       result = Dali::NativeImage::DownCast(arg1);
42309     } catch (std::out_of_range& e) {
42310       {
42311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42312       };
42313     } catch (std::exception& e) {
42314       {
42315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (...) {
42318       {
42319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42320       };
42321     }
42322   }
42323   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42329   char * jresult ;
42330   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42331   char *result = 0 ;
42332
42333   arg1 = (Dali::NativeImage *)jarg1;
42334   {
42335     try {
42336       result = (char *)(arg1)->GetCustomFragmentPreFix();
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (...) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42348       };
42349     }
42350   }
42351   jresult = SWIG_csharp_string_callback((const char *)result);
42352   return jresult;
42353 }
42354
42355
42356 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42357   char * jresult ;
42358   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42359   char *result = 0 ;
42360
42361   arg1 = (Dali::NativeImage *)jarg1;
42362   {
42363     try {
42364       result = (char *)(arg1)->GetCustomSamplerTypename();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = SWIG_csharp_string_callback((const char *)result);
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42385   unsigned int jresult ;
42386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42387   bool result;
42388
42389   arg1 = (Dali::NativeImageInterface *)jarg1;
42390   {
42391     try {
42392       result = (bool)(arg1)->GlExtensionCreate();
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42404       };
42405     }
42406   }
42407   jresult = result;
42408   return jresult;
42409 }
42410
42411
42412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42413   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42414
42415   arg1 = (Dali::NativeImageInterface *)jarg1;
42416   {
42417     try {
42418       (arg1)->GlExtensionDestroy();
42419     } catch (std::out_of_range& e) {
42420       {
42421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42422       };
42423     } catch (std::exception& e) {
42424       {
42425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42430       };
42431     }
42432   }
42433 }
42434
42435
42436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42437   unsigned int jresult ;
42438   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42439   unsigned int result;
42440
42441   arg1 = (Dali::NativeImageInterface *)jarg1;
42442   {
42443     try {
42444       result = (unsigned int)(arg1)->TargetTexture();
42445     } catch (std::out_of_range& e) {
42446       {
42447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (std::exception& e) {
42450       {
42451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (...) {
42454       {
42455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42456       };
42457     }
42458   }
42459   jresult = result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42466
42467   arg1 = (Dali::NativeImageInterface *)jarg1;
42468   {
42469     try {
42470       (arg1)->PrepareTexture();
42471     } catch (std::out_of_range& e) {
42472       {
42473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42474       };
42475     } catch (std::exception& e) {
42476       {
42477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (...) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42482       };
42483     }
42484   }
42485 }
42486
42487
42488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42489   unsigned int jresult ;
42490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42491   unsigned int result;
42492
42493   arg1 = (Dali::NativeImageInterface *)jarg1;
42494   {
42495     try {
42496       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42497     } catch (std::out_of_range& e) {
42498       {
42499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (std::exception& e) {
42502       {
42503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42508       };
42509     }
42510   }
42511   jresult = result;
42512   return jresult;
42513 }
42514
42515
42516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42517   unsigned int jresult ;
42518   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42519   unsigned int result;
42520
42521   arg1 = (Dali::NativeImageInterface *)jarg1;
42522   {
42523     try {
42524       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42525     } catch (std::out_of_range& e) {
42526       {
42527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (std::exception& e) {
42530       {
42531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42532       };
42533     } catch (...) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42536       };
42537     }
42538   }
42539   jresult = result;
42540   return jresult;
42541 }
42542
42543
42544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42545   unsigned int jresult ;
42546   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42547   bool result;
42548
42549   arg1 = (Dali::NativeImageInterface *)jarg1;
42550   {
42551     try {
42552       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42553     } catch (std::out_of_range& e) {
42554       {
42555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42556       };
42557     } catch (std::exception& e) {
42558       {
42559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42560       };
42561     } catch (...) {
42562       {
42563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42564       };
42565     }
42566   }
42567   jresult = result;
42568   return jresult;
42569 }
42570
42571
42572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42573   void * jresult ;
42574   std::string *arg1 = 0 ;
42575   Dali::ImageDimensions result;
42576
42577   if (!jarg1) {
42578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42579     return 0;
42580   }
42581   std::string arg1_str(jarg1);
42582   arg1 = &arg1_str;
42583   {
42584     try {
42585       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42586     } catch (std::out_of_range& e) {
42587       {
42588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (std::exception& e) {
42591       {
42592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42601
42602   //argout typemap for const std::string&
42603
42604   return jresult;
42605 }
42606
42607
42608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42609   void * jresult ;
42610   Dali::ResourceImage *result = 0 ;
42611
42612   {
42613     try {
42614       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (...) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42626       };
42627     }
42628   }
42629   jresult = (void *)result;
42630   return jresult;
42631 }
42632
42633
42634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42635   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42636
42637   arg1 = (Dali::ResourceImage *)jarg1;
42638   {
42639     try {
42640       delete arg1;
42641     } catch (std::out_of_range& e) {
42642       {
42643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42644       };
42645     } catch (std::exception& e) {
42646       {
42647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42648       };
42649     } catch (...) {
42650       {
42651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42652       };
42653     }
42654   }
42655 }
42656
42657
42658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42659   void * jresult ;
42660   Dali::ResourceImage *arg1 = 0 ;
42661   Dali::ResourceImage *result = 0 ;
42662
42663   arg1 = (Dali::ResourceImage *)jarg1;
42664   if (!arg1) {
42665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42666     return 0;
42667   }
42668   {
42669     try {
42670       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42671     } catch (std::out_of_range& e) {
42672       {
42673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (std::exception& e) {
42676       {
42677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42691   void * jresult ;
42692   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42693   Dali::ResourceImage *arg2 = 0 ;
42694   Dali::ResourceImage *result = 0 ;
42695
42696   arg1 = (Dali::ResourceImage *)jarg1;
42697   arg2 = (Dali::ResourceImage *)jarg2;
42698   if (!arg2) {
42699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42700     return 0;
42701   }
42702   {
42703     try {
42704       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42705     } catch (std::out_of_range& e) {
42706       {
42707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42708       };
42709     } catch (std::exception& e) {
42710       {
42711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42712       };
42713     } catch (...) {
42714       {
42715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42716       };
42717     }
42718   }
42719   jresult = (void *)result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42725   void * jresult ;
42726   std::string *arg1 = 0 ;
42727   bool arg2 ;
42728   Dali::ResourceImage result;
42729
42730   if (!jarg1) {
42731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42732     return 0;
42733   }
42734   std::string arg1_str(jarg1);
42735   arg1 = &arg1_str;
42736   arg2 = jarg2 ? true : false;
42737   {
42738     try {
42739       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42755
42756   //argout typemap for const std::string&
42757
42758   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42763   void * jresult ;
42764   std::string *arg1 = 0 ;
42765   Dali::ResourceImage result;
42766
42767   if (!jarg1) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42769     return 0;
42770   }
42771   std::string arg1_str(jarg1);
42772   arg1 = &arg1_str;
42773   {
42774     try {
42775       result = Dali::ResourceImage::New((std::string const &)*arg1);
42776     } catch (std::out_of_range& e) {
42777       {
42778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42779       };
42780     } catch (std::exception& e) {
42781       {
42782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (...) {
42785       {
42786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42787       };
42788     }
42789   }
42790   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42791
42792   //argout typemap for const std::string&
42793
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42799   void * jresult ;
42800   std::string *arg1 = 0 ;
42801   Dali::ImageDimensions arg2 ;
42802   Dali::FittingMode::Type arg3 ;
42803   Dali::SamplingMode::Type arg4 ;
42804   bool arg5 ;
42805   Dali::ImageDimensions *argp2 ;
42806   Dali::ResourceImage result;
42807
42808   if (!jarg1) {
42809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42810     return 0;
42811   }
42812   std::string arg1_str(jarg1);
42813   arg1 = &arg1_str;
42814   argp2 = (Dali::ImageDimensions *)jarg2;
42815   if (!argp2) {
42816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42817     return 0;
42818   }
42819   arg2 = *argp2;
42820   arg3 = (Dali::FittingMode::Type)jarg3;
42821   arg4 = (Dali::SamplingMode::Type)jarg4;
42822   arg5 = jarg5 ? true : false;
42823   {
42824     try {
42825       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42837       };
42838     }
42839   }
42840   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42841
42842   //argout typemap for const std::string&
42843
42844   return jresult;
42845 }
42846
42847
42848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42849   void * jresult ;
42850   std::string *arg1 = 0 ;
42851   Dali::ImageDimensions arg2 ;
42852   Dali::FittingMode::Type arg3 ;
42853   Dali::SamplingMode::Type arg4 ;
42854   Dali::ImageDimensions *argp2 ;
42855   Dali::ResourceImage result;
42856
42857   if (!jarg1) {
42858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42859     return 0;
42860   }
42861   std::string arg1_str(jarg1);
42862   arg1 = &arg1_str;
42863   argp2 = (Dali::ImageDimensions *)jarg2;
42864   if (!argp2) {
42865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42866     return 0;
42867   }
42868   arg2 = *argp2;
42869   arg3 = (Dali::FittingMode::Type)jarg3;
42870   arg4 = (Dali::SamplingMode::Type)jarg4;
42871   {
42872     try {
42873       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42874     } catch (std::out_of_range& e) {
42875       {
42876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42877       };
42878     } catch (std::exception& e) {
42879       {
42880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (...) {
42883       {
42884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42885       };
42886     }
42887   }
42888   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42889
42890   //argout typemap for const std::string&
42891
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42897   void * jresult ;
42898   std::string *arg1 = 0 ;
42899   Dali::ImageDimensions arg2 ;
42900   Dali::FittingMode::Type arg3 ;
42901   Dali::ImageDimensions *argp2 ;
42902   Dali::ResourceImage result;
42903
42904   if (!jarg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42906     return 0;
42907   }
42908   std::string arg1_str(jarg1);
42909   arg1 = &arg1_str;
42910   argp2 = (Dali::ImageDimensions *)jarg2;
42911   if (!argp2) {
42912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42913     return 0;
42914   }
42915   arg2 = *argp2;
42916   arg3 = (Dali::FittingMode::Type)jarg3;
42917   {
42918     try {
42919       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42935
42936   //argout typemap for const std::string&
42937
42938   return jresult;
42939 }
42940
42941
42942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42943   void * jresult ;
42944   std::string *arg1 = 0 ;
42945   Dali::ImageDimensions arg2 ;
42946   Dali::ImageDimensions *argp2 ;
42947   Dali::ResourceImage result;
42948
42949   if (!jarg1) {
42950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42951     return 0;
42952   }
42953   std::string arg1_str(jarg1);
42954   arg1 = &arg1_str;
42955   argp2 = (Dali::ImageDimensions *)jarg2;
42956   if (!argp2) {
42957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42958     return 0;
42959   }
42960   arg2 = *argp2;
42961   {
42962     try {
42963       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (...) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42975       };
42976     }
42977   }
42978   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42979
42980   //argout typemap for const std::string&
42981
42982   return jresult;
42983 }
42984
42985
42986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42987   void * jresult ;
42988   Dali::BaseHandle arg1 ;
42989   Dali::BaseHandle *argp1 ;
42990   Dali::ResourceImage result;
42991
42992   argp1 = (Dali::BaseHandle *)jarg1;
42993   if (!argp1) {
42994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42995     return 0;
42996   }
42997   arg1 = *argp1;
42998   {
42999     try {
43000       result = Dali::ResourceImage::DownCast(arg1);
43001     } catch (std::out_of_range& e) {
43002       {
43003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (std::exception& e) {
43006       {
43007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (...) {
43010       {
43011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43012       };
43013     }
43014   }
43015   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
43021   int jresult ;
43022   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43023   Dali::LoadingState result;
43024
43025   arg1 = (Dali::ResourceImage *)jarg1;
43026   {
43027     try {
43028       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (int)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
43049   char * jresult ;
43050   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43051   std::string result;
43052
43053   arg1 = (Dali::ResourceImage *)jarg1;
43054   {
43055     try {
43056       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43068       };
43069     }
43070   }
43071   jresult = SWIG_csharp_string_callback((&result)->c_str());
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
43077   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43078
43079   arg1 = (Dali::ResourceImage *)jarg1;
43080   {
43081     try {
43082       (arg1)->Reload();
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43094       };
43095     }
43096   }
43097 }
43098
43099
43100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43101   void * jresult ;
43102   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43103   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43104
43105   arg1 = (Dali::ResourceImage *)jarg1;
43106   {
43107     try {
43108       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43109     } catch (std::out_of_range& e) {
43110       {
43111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (std::exception& e) {
43114       {
43115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43120       };
43121     }
43122   }
43123   jresult = (void *)result;
43124   return jresult;
43125 }
43126
43127
43128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43129   void * jresult ;
43130   Dali::FrameBufferImage *result = 0 ;
43131
43132   {
43133     try {
43134       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43135     } catch (std::out_of_range& e) {
43136       {
43137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43138       };
43139     } catch (std::exception& e) {
43140       {
43141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43142       };
43143     } catch (...) {
43144       {
43145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43146       };
43147     }
43148   }
43149   jresult = (void *)result;
43150   return jresult;
43151 }
43152
43153
43154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43155   void * jresult ;
43156   unsigned int arg1 ;
43157   unsigned int arg2 ;
43158   Dali::Pixel::Format arg3 ;
43159   Dali::RenderBuffer::Format arg4 ;
43160   Dali::FrameBufferImage result;
43161
43162   arg1 = (unsigned int)jarg1;
43163   arg2 = (unsigned int)jarg2;
43164   arg3 = (Dali::Pixel::Format)jarg3;
43165   arg4 = (Dali::RenderBuffer::Format)jarg4;
43166   {
43167     try {
43168       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43169     } catch (std::out_of_range& e) {
43170       {
43171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43172       };
43173     } catch (std::exception& e) {
43174       {
43175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43176       };
43177     } catch (...) {
43178       {
43179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43180       };
43181     }
43182   }
43183   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43184   return jresult;
43185 }
43186
43187
43188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43189   void * jresult ;
43190   unsigned int arg1 ;
43191   unsigned int arg2 ;
43192   Dali::Pixel::Format arg3 ;
43193   Dali::FrameBufferImage result;
43194
43195   arg1 = (unsigned int)jarg1;
43196   arg2 = (unsigned int)jarg2;
43197   arg3 = (Dali::Pixel::Format)jarg3;
43198   {
43199     try {
43200       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43201     } catch (std::out_of_range& e) {
43202       {
43203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (std::exception& e) {
43206       {
43207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43221   void * jresult ;
43222   unsigned int arg1 ;
43223   unsigned int arg2 ;
43224   Dali::FrameBufferImage result;
43225
43226   arg1 = (unsigned int)jarg1;
43227   arg2 = (unsigned int)jarg2;
43228   {
43229     try {
43230       result = Dali::FrameBufferImage::New(arg1,arg2);
43231     } catch (std::out_of_range& e) {
43232       {
43233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43234       };
43235     } catch (std::exception& e) {
43236       {
43237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43238       };
43239     } catch (...) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43242       };
43243     }
43244   }
43245   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43246   return jresult;
43247 }
43248
43249
43250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43251   void * jresult ;
43252   unsigned int arg1 ;
43253   Dali::FrameBufferImage result;
43254
43255   arg1 = (unsigned int)jarg1;
43256   {
43257     try {
43258       result = Dali::FrameBufferImage::New(arg1);
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43266       };
43267     } catch (...) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43270       };
43271     }
43272   }
43273   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43274   return jresult;
43275 }
43276
43277
43278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43279   void * jresult ;
43280   Dali::FrameBufferImage result;
43281
43282   {
43283     try {
43284       result = Dali::FrameBufferImage::New();
43285     } catch (std::out_of_range& e) {
43286       {
43287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43288       };
43289     } catch (std::exception& e) {
43290       {
43291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43292       };
43293     } catch (...) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43296       };
43297     }
43298   }
43299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43300   return jresult;
43301 }
43302
43303
43304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43305   void * jresult ;
43306   Dali::NativeImageInterface *arg1 = 0 ;
43307   Dali::FrameBufferImage result;
43308
43309   arg1 = (Dali::NativeImageInterface *)jarg1;
43310   if (!arg1) {
43311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43312     return 0;
43313   }
43314   {
43315     try {
43316       result = Dali::FrameBufferImage::New(*arg1);
43317     } catch (std::out_of_range& e) {
43318       {
43319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43320       };
43321     } catch (std::exception& e) {
43322       {
43323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43328       };
43329     }
43330   }
43331   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43337   void * jresult ;
43338   Dali::BaseHandle arg1 ;
43339   Dali::BaseHandle *argp1 ;
43340   Dali::FrameBufferImage result;
43341
43342   argp1 = (Dali::BaseHandle *)jarg1;
43343   if (!argp1) {
43344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43345     return 0;
43346   }
43347   arg1 = *argp1;
43348   {
43349     try {
43350       result = Dali::FrameBufferImage::DownCast(arg1);
43351     } catch (std::out_of_range& e) {
43352       {
43353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (std::exception& e) {
43356       {
43357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43371   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43372
43373   arg1 = (Dali::FrameBufferImage *)jarg1;
43374   {
43375     try {
43376       delete arg1;
43377     } catch (std::out_of_range& e) {
43378       {
43379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43380       };
43381     } catch (std::exception& e) {
43382       {
43383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43384       };
43385     } catch (...) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43388       };
43389     }
43390   }
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43395   void * jresult ;
43396   Dali::FrameBufferImage *arg1 = 0 ;
43397   Dali::FrameBufferImage *result = 0 ;
43398
43399   arg1 = (Dali::FrameBufferImage *)jarg1;
43400   if (!arg1) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43402     return 0;
43403   }
43404   {
43405     try {
43406       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43427   void * jresult ;
43428   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43429   Dali::FrameBufferImage *arg2 = 0 ;
43430   Dali::FrameBufferImage *result = 0 ;
43431
43432   arg1 = (Dali::FrameBufferImage *)jarg1;
43433   arg2 = (Dali::FrameBufferImage *)jarg2;
43434   if (!arg2) {
43435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43436     return 0;
43437   }
43438   {
43439     try {
43440       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43441     } catch (std::out_of_range& e) {
43442       {
43443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (std::exception& e) {
43446       {
43447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43448       };
43449     } catch (...) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43452       };
43453     }
43454   }
43455   jresult = (void *)result;
43456   return jresult;
43457 }
43458
43459
43460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43461   void * jresult ;
43462   Dali::NinePatchImage *result = 0 ;
43463
43464   {
43465     try {
43466       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43467     } catch (std::out_of_range& e) {
43468       {
43469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (std::exception& e) {
43472       {
43473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (...) {
43476       {
43477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43478       };
43479     }
43480   }
43481   jresult = (void *)result;
43482   return jresult;
43483 }
43484
43485
43486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43487   void * jresult ;
43488   std::string *arg1 = 0 ;
43489   Dali::NinePatchImage result;
43490
43491   if (!jarg1) {
43492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43493     return 0;
43494   }
43495   std::string arg1_str(jarg1);
43496   arg1 = &arg1_str;
43497   {
43498     try {
43499       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (...) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43511       };
43512     }
43513   }
43514   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43515
43516   //argout typemap for const std::string&
43517
43518   return jresult;
43519 }
43520
43521
43522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43523   void * jresult ;
43524   Dali::BaseHandle arg1 ;
43525   Dali::BaseHandle *argp1 ;
43526   Dali::NinePatchImage result;
43527
43528   argp1 = (Dali::BaseHandle *)jarg1;
43529   if (!argp1) {
43530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43531     return 0;
43532   }
43533   arg1 = *argp1;
43534   {
43535     try {
43536       result = Dali::NinePatchImage::DownCast(arg1);
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43548       };
43549     }
43550   }
43551   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43552   return jresult;
43553 }
43554
43555
43556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43557   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43558
43559   arg1 = (Dali::NinePatchImage *)jarg1;
43560   {
43561     try {
43562       delete arg1;
43563     } catch (std::out_of_range& e) {
43564       {
43565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43566       };
43567     } catch (std::exception& e) {
43568       {
43569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43570       };
43571     } catch (...) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43574       };
43575     }
43576   }
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43581   void * jresult ;
43582   Dali::NinePatchImage *arg1 = 0 ;
43583   Dali::NinePatchImage *result = 0 ;
43584
43585   arg1 = (Dali::NinePatchImage *)jarg1;
43586   if (!arg1) {
43587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43588     return 0;
43589   }
43590   {
43591     try {
43592       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607   jresult = (void *)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43613   void * jresult ;
43614   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43615   Dali::NinePatchImage *arg2 = 0 ;
43616   Dali::NinePatchImage *result = 0 ;
43617
43618   arg1 = (Dali::NinePatchImage *)jarg1;
43619   arg2 = (Dali::NinePatchImage *)jarg2;
43620   if (!arg2) {
43621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43622     return 0;
43623   }
43624   {
43625     try {
43626       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43627     } catch (std::out_of_range& e) {
43628       {
43629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (std::exception& e) {
43632       {
43633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43647   void * jresult ;
43648   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43649   Dali::Vector4 result;
43650
43651   arg1 = (Dali::NinePatchImage *)jarg1;
43652   {
43653     try {
43654       result = (arg1)->GetStretchBorders();
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43666       };
43667     }
43668   }
43669   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43675   void * jresult ;
43676   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43677   Dali::NinePatchImage::StretchRanges *result = 0 ;
43678
43679   arg1 = (Dali::NinePatchImage *)jarg1;
43680   {
43681     try {
43682       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43683     } catch (std::out_of_range& e) {
43684       {
43685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (std::exception& e) {
43688       {
43689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697   jresult = (void *)result;
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43703   void * jresult ;
43704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43705   Dali::NinePatchImage::StretchRanges *result = 0 ;
43706
43707   arg1 = (Dali::NinePatchImage *)jarg1;
43708   {
43709     try {
43710       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43711     } catch (std::out_of_range& e) {
43712       {
43713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43714       };
43715     } catch (std::exception& e) {
43716       {
43717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (...) {
43720       {
43721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43722       };
43723     }
43724   }
43725   jresult = (void *)result;
43726   return jresult;
43727 }
43728
43729
43730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43731   void * jresult ;
43732   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43733   Dali::Rect< int > result;
43734
43735   arg1 = (Dali::NinePatchImage *)jarg1;
43736   {
43737     try {
43738       result = (arg1)->GetChildRectangle();
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (...) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43750       };
43751     }
43752   }
43753   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43759   void * jresult ;
43760   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43761   Dali::BufferImage result;
43762
43763   arg1 = (Dali::NinePatchImage *)jarg1;
43764   {
43765     try {
43766       result = (arg1)->CreateCroppedBufferImage();
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43774       };
43775     } catch (...) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43778       };
43779     }
43780   }
43781   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43782   return jresult;
43783 }
43784
43785
43786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43787   unsigned int jresult ;
43788   std::string *arg1 = 0 ;
43789   bool result;
43790
43791   if (!jarg1) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43793     return 0;
43794   }
43795   std::string arg1_str(jarg1);
43796   arg1 = &arg1_str;
43797   {
43798     try {
43799       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43800     } catch (std::out_of_range& e) {
43801       {
43802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43803       };
43804     } catch (std::exception& e) {
43805       {
43806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (...) {
43809       {
43810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43811       };
43812     }
43813   }
43814   jresult = result;
43815
43816   //argout typemap for const std::string&
43817
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43823   int jresult ;
43824   int result;
43825
43826   result = (int)Dali::CameraActor::Property::TYPE;
43827   jresult = (int)result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43833   int jresult ;
43834   int result;
43835
43836   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43837   jresult = (int)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43843   int jresult ;
43844   int result;
43845
43846   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43847   jresult = (int)result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43853   int jresult ;
43854   int result;
43855
43856   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43857   jresult = (int)result;
43858   return jresult;
43859 }
43860
43861
43862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43863   int jresult ;
43864   int result;
43865
43866   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43867   jresult = (int)result;
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43873   int jresult ;
43874   int result;
43875
43876   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43877   jresult = (int)result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43883   int jresult ;
43884   int result;
43885
43886   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43887   jresult = (int)result;
43888   return jresult;
43889 }
43890
43891
43892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43893   int jresult ;
43894   int result;
43895
43896   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43897   jresult = (int)result;
43898   return jresult;
43899 }
43900
43901
43902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43903   int jresult ;
43904   int result;
43905
43906   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43907   jresult = (int)result;
43908   return jresult;
43909 }
43910
43911
43912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43913   int jresult ;
43914   int result;
43915
43916   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43917   jresult = (int)result;
43918   return jresult;
43919 }
43920
43921
43922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43923   int jresult ;
43924   int result;
43925
43926   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43927   jresult = (int)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43933   int jresult ;
43934   int result;
43935
43936   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43937   jresult = (int)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43943   int jresult ;
43944   int result;
43945
43946   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43947   jresult = (int)result;
43948   return jresult;
43949 }
43950
43951
43952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43953   int jresult ;
43954   int result;
43955
43956   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43957   jresult = (int)result;
43958   return jresult;
43959 }
43960
43961
43962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43963   void * jresult ;
43964   Dali::CameraActor::Property *result = 0 ;
43965
43966   {
43967     try {
43968       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43969     } catch (std::out_of_range& e) {
43970       {
43971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43972       };
43973     } catch (std::exception& e) {
43974       {
43975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43976       };
43977     } catch (...) {
43978       {
43979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43980       };
43981     }
43982   }
43983   jresult = (void *)result;
43984   return jresult;
43985 }
43986
43987
43988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43989   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43990
43991   arg1 = (Dali::CameraActor::Property *)jarg1;
43992   {
43993     try {
43994       delete arg1;
43995     } catch (std::out_of_range& e) {
43996       {
43997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43998       };
43999     } catch (std::exception& e) {
44000       {
44001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44002       };
44003     } catch (...) {
44004       {
44005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44006       };
44007     }
44008   }
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44013   void * jresult ;
44014   Dali::CameraActor *result = 0 ;
44015
44016   {
44017     try {
44018       result = (Dali::CameraActor *)new Dali::CameraActor();
44019     } catch (std::out_of_range& e) {
44020       {
44021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (std::exception& e) {
44024       {
44025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033   jresult = (void *)result;
44034   return jresult;
44035 }
44036
44037
44038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44039   void * jresult ;
44040   Dali::CameraActor result;
44041
44042   {
44043     try {
44044       result = Dali::CameraActor::New();
44045     } catch (std::out_of_range& e) {
44046       {
44047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44048       };
44049     } catch (std::exception& e) {
44050       {
44051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44056       };
44057     }
44058   }
44059   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44060   return jresult;
44061 }
44062
44063
44064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44065   void * jresult ;
44066   Dali::Size *arg1 = 0 ;
44067   Dali::CameraActor result;
44068
44069   arg1 = (Dali::Size *)jarg1;
44070   if (!arg1) {
44071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44072     return 0;
44073   }
44074   {
44075     try {
44076       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44077     } catch (std::out_of_range& e) {
44078       {
44079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44080       };
44081     } catch (std::exception& e) {
44082       {
44083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44084       };
44085     } catch (...) {
44086       {
44087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44088       };
44089     }
44090   }
44091   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44092   return jresult;
44093 }
44094
44095
44096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44097   void * jresult ;
44098   Dali::BaseHandle arg1 ;
44099   Dali::BaseHandle *argp1 ;
44100   Dali::CameraActor result;
44101
44102   argp1 = (Dali::BaseHandle *)jarg1;
44103   if (!argp1) {
44104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44105     return 0;
44106   }
44107   arg1 = *argp1;
44108   {
44109     try {
44110       result = Dali::CameraActor::DownCast(arg1);
44111     } catch (std::out_of_range& e) {
44112       {
44113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44114       };
44115     } catch (std::exception& e) {
44116       {
44117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44118       };
44119     } catch (...) {
44120       {
44121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44122       };
44123     }
44124   }
44125   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44126   return jresult;
44127 }
44128
44129
44130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44131   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44132
44133   arg1 = (Dali::CameraActor *)jarg1;
44134   {
44135     try {
44136       delete arg1;
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44148       };
44149     }
44150   }
44151 }
44152
44153
44154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44155   void * jresult ;
44156   Dali::CameraActor *arg1 = 0 ;
44157   Dali::CameraActor *result = 0 ;
44158
44159   arg1 = (Dali::CameraActor *)jarg1;
44160   if (!arg1) {
44161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44162     return 0;
44163   }
44164   {
44165     try {
44166       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44167     } catch (std::out_of_range& e) {
44168       {
44169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44170       };
44171     } catch (std::exception& e) {
44172       {
44173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (...) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44178       };
44179     }
44180   }
44181   jresult = (void *)result;
44182   return jresult;
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44187   void * jresult ;
44188   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44189   Dali::CameraActor *arg2 = 0 ;
44190   Dali::CameraActor *result = 0 ;
44191
44192   arg1 = (Dali::CameraActor *)jarg1;
44193   arg2 = (Dali::CameraActor *)jarg2;
44194   if (!arg2) {
44195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44196     return 0;
44197   }
44198   {
44199     try {
44200       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44201     } catch (std::out_of_range& e) {
44202       {
44203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44204       };
44205     } catch (std::exception& e) {
44206       {
44207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44208       };
44209     } catch (...) {
44210       {
44211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44212       };
44213     }
44214   }
44215   jresult = (void *)result;
44216   return jresult;
44217 }
44218
44219
44220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44221   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44222   Dali::Camera::Type arg2 ;
44223
44224   arg1 = (Dali::CameraActor *)jarg1;
44225   arg2 = (Dali::Camera::Type)jarg2;
44226   {
44227     try {
44228       (arg1)->SetType(arg2);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44240       };
44241     }
44242   }
44243 }
44244
44245
44246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44247   int jresult ;
44248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44249   Dali::Camera::Type result;
44250
44251   arg1 = (Dali::CameraActor *)jarg1;
44252   {
44253     try {
44254       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44255     } catch (std::out_of_range& e) {
44256       {
44257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44258       };
44259     } catch (std::exception& e) {
44260       {
44261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44262       };
44263     } catch (...) {
44264       {
44265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44266       };
44267     }
44268   }
44269   jresult = (int)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44275   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44276   Dali::Camera::ProjectionMode arg2 ;
44277
44278   arg1 = (Dali::CameraActor *)jarg1;
44279   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44280   {
44281     try {
44282       (arg1)->SetProjectionMode(arg2);
44283     } catch (std::out_of_range& e) {
44284       {
44285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44286       };
44287     } catch (std::exception& e) {
44288       {
44289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (...) {
44292       {
44293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44294       };
44295     }
44296   }
44297 }
44298
44299
44300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44301   int jresult ;
44302   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44303   Dali::Camera::ProjectionMode result;
44304
44305   arg1 = (Dali::CameraActor *)jarg1;
44306   {
44307     try {
44308       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44309     } catch (std::out_of_range& e) {
44310       {
44311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44312       };
44313     } catch (std::exception& e) {
44314       {
44315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44316       };
44317     } catch (...) {
44318       {
44319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44320       };
44321     }
44322   }
44323   jresult = (int)result;
44324   return jresult;
44325 }
44326
44327
44328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44330   float arg2 ;
44331
44332   arg1 = (Dali::CameraActor *)jarg1;
44333   arg2 = (float)jarg2;
44334   {
44335     try {
44336       (arg1)->SetFieldOfView(arg2);
44337     } catch (std::out_of_range& e) {
44338       {
44339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44340       };
44341     } catch (std::exception& e) {
44342       {
44343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44344       };
44345     } catch (...) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44348       };
44349     }
44350   }
44351 }
44352
44353
44354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44355   float jresult ;
44356   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44357   float result;
44358
44359   arg1 = (Dali::CameraActor *)jarg1;
44360   {
44361     try {
44362       result = (float)(arg1)->GetFieldOfView();
44363     } catch (std::out_of_range& e) {
44364       {
44365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (std::exception& e) {
44368       {
44369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44370       };
44371     } catch (...) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44374       };
44375     }
44376   }
44377   jresult = result;
44378   return jresult;
44379 }
44380
44381
44382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44384   float arg2 ;
44385
44386   arg1 = (Dali::CameraActor *)jarg1;
44387   arg2 = (float)jarg2;
44388   {
44389     try {
44390       (arg1)->SetAspectRatio(arg2);
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44398       };
44399     } catch (...) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44402       };
44403     }
44404   }
44405 }
44406
44407
44408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44409   float jresult ;
44410   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44411   float result;
44412
44413   arg1 = (Dali::CameraActor *)jarg1;
44414   {
44415     try {
44416       result = (float)(arg1)->GetAspectRatio();
44417     } catch (std::out_of_range& e) {
44418       {
44419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44420       };
44421     } catch (std::exception& e) {
44422       {
44423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44424       };
44425     } catch (...) {
44426       {
44427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44428       };
44429     }
44430   }
44431   jresult = result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44437   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44438   float arg2 ;
44439
44440   arg1 = (Dali::CameraActor *)jarg1;
44441   arg2 = (float)jarg2;
44442   {
44443     try {
44444       (arg1)->SetNearClippingPlane(arg2);
44445     } catch (std::out_of_range& e) {
44446       {
44447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44448       };
44449     } catch (std::exception& e) {
44450       {
44451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44452       };
44453     } catch (...) {
44454       {
44455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44456       };
44457     }
44458   }
44459 }
44460
44461
44462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44463   float jresult ;
44464   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44465   float result;
44466
44467   arg1 = (Dali::CameraActor *)jarg1;
44468   {
44469     try {
44470       result = (float)(arg1)->GetNearClippingPlane();
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44478       };
44479     } catch (...) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44482       };
44483     }
44484   }
44485   jresult = result;
44486   return jresult;
44487 }
44488
44489
44490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44491   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44492   float arg2 ;
44493
44494   arg1 = (Dali::CameraActor *)jarg1;
44495   arg2 = (float)jarg2;
44496   {
44497     try {
44498       (arg1)->SetFarClippingPlane(arg2);
44499     } catch (std::out_of_range& e) {
44500       {
44501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44502       };
44503     } catch (std::exception& e) {
44504       {
44505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44506       };
44507     } catch (...) {
44508       {
44509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44510       };
44511     }
44512   }
44513 }
44514
44515
44516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44517   float jresult ;
44518   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44519   float result;
44520
44521   arg1 = (Dali::CameraActor *)jarg1;
44522   {
44523     try {
44524       result = (float)(arg1)->GetFarClippingPlane();
44525     } catch (std::out_of_range& e) {
44526       {
44527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44528       };
44529     } catch (std::exception& e) {
44530       {
44531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44536       };
44537     }
44538   }
44539   jresult = result;
44540   return jresult;
44541 }
44542
44543
44544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44545   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44546   Dali::Vector3 *arg2 = 0 ;
44547
44548   arg1 = (Dali::CameraActor *)jarg1;
44549   arg2 = (Dali::Vector3 *)jarg2;
44550   if (!arg2) {
44551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44552     return ;
44553   }
44554   {
44555     try {
44556       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44557     } catch (std::out_of_range& e) {
44558       {
44559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (std::exception& e) {
44562       {
44563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44568       };
44569     }
44570   }
44571 }
44572
44573
44574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44575   void * jresult ;
44576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44577   Dali::Vector3 result;
44578
44579   arg1 = (Dali::CameraActor *)jarg1;
44580   {
44581     try {
44582       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44583     } catch (std::out_of_range& e) {
44584       {
44585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (std::exception& e) {
44588       {
44589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44590       };
44591     } catch (...) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44594       };
44595     }
44596   }
44597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44598   return jresult;
44599 }
44600
44601
44602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44604   bool arg2 ;
44605
44606   arg1 = (Dali::CameraActor *)jarg1;
44607   arg2 = jarg2 ? true : false;
44608   {
44609     try {
44610       (arg1)->SetInvertYAxis(arg2);
44611     } catch (std::out_of_range& e) {
44612       {
44613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44614       };
44615     } catch (std::exception& e) {
44616       {
44617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44618       };
44619     } catch (...) {
44620       {
44621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44622       };
44623     }
44624   }
44625 }
44626
44627
44628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44629   unsigned int jresult ;
44630   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44631   bool result;
44632
44633   arg1 = (Dali::CameraActor *)jarg1;
44634   {
44635     try {
44636       result = (bool)(arg1)->GetInvertYAxis();
44637     } catch (std::out_of_range& e) {
44638       {
44639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44640       };
44641     } catch (std::exception& e) {
44642       {
44643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44644       };
44645     } catch (...) {
44646       {
44647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44648       };
44649     }
44650   }
44651   jresult = result;
44652   return jresult;
44653 }
44654
44655
44656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44658   Dali::Size *arg2 = 0 ;
44659
44660   arg1 = (Dali::CameraActor *)jarg1;
44661   arg2 = (Dali::Size *)jarg2;
44662   if (!arg2) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44664     return ;
44665   }
44666   {
44667     try {
44668       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44676       };
44677     } catch (...) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44680       };
44681     }
44682   }
44683 }
44684
44685
44686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44687   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44688   Dali::Size *arg2 = 0 ;
44689
44690   arg1 = (Dali::CameraActor *)jarg1;
44691   arg2 = (Dali::Size *)jarg2;
44692   if (!arg2) {
44693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44694     return ;
44695   }
44696   {
44697     try {
44698       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44710       };
44711     }
44712   }
44713 }
44714
44715
44716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44717   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44718   float arg2 ;
44719   float arg3 ;
44720   float arg4 ;
44721   float arg5 ;
44722   float arg6 ;
44723   float arg7 ;
44724
44725   arg1 = (Dali::CameraActor *)jarg1;
44726   arg2 = (float)jarg2;
44727   arg3 = (float)jarg3;
44728   arg4 = (float)jarg4;
44729   arg5 = (float)jarg5;
44730   arg6 = (float)jarg6;
44731   arg7 = (float)jarg7;
44732   {
44733     try {
44734       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44735     } catch (std::out_of_range& e) {
44736       {
44737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44738       };
44739     } catch (std::exception& e) {
44740       {
44741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44742       };
44743     } catch (...) {
44744       {
44745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44746       };
44747     }
44748   }
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44753   void * jresult ;
44754   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44755
44756   {
44757     try {
44758       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44766       };
44767     } catch (...) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44770       };
44771     }
44772   }
44773   jresult = (void *)result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44779   void * jresult ;
44780   std::string arg1 ;
44781   Dali::Property::Value arg2 ;
44782   Dali::Property::Value *argp2 ;
44783   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44784
44785   if (!jarg1) {
44786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44787     return 0;
44788   }
44789   (&arg1)->assign(jarg1);
44790   argp2 = (Dali::Property::Value *)jarg2;
44791   if (!argp2) {
44792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44793     return 0;
44794   }
44795   arg2 = *argp2;
44796   {
44797     try {
44798       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44799     } catch (std::out_of_range& e) {
44800       {
44801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44802       };
44803     } catch (std::exception& e) {
44804       {
44805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44806       };
44807     } catch (...) {
44808       {
44809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44810       };
44811     }
44812   }
44813   jresult = (void *)result;
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44819   void * jresult ;
44820   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44821   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44822
44823   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44824   if (!arg1) {
44825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44826     return 0;
44827   }
44828   {
44829     try {
44830       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
44831     } catch (std::out_of_range& e) {
44832       {
44833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (std::exception& e) {
44836       {
44837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44838       };
44839     } catch (...) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44842       };
44843     }
44844   }
44845   jresult = (void *)result;
44846   return jresult;
44847 }
44848
44849
44850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44851   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44852   std::string *arg2 = 0 ;
44853
44854   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44855   if (!jarg2) {
44856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44857     return ;
44858   }
44859   std::string arg2_str(jarg2);
44860   arg2 = &arg2_str;
44861   if (arg1) (arg1)->first = *arg2;
44862
44863   //argout typemap for const std::string&
44864
44865 }
44866
44867
44868 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44869   char * jresult ;
44870   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44871   std::string *result = 0 ;
44872
44873   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44874   result = (std::string *) & ((arg1)->first);
44875   jresult = SWIG_csharp_string_callback(result->c_str());
44876   return jresult;
44877 }
44878
44879
44880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44881   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44882   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44883
44884   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44885   arg2 = (Dali::Property::Value *)jarg2;
44886   if (arg1) (arg1)->second = *arg2;
44887 }
44888
44889
44890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44891   void * jresult ;
44892   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44893   Dali::Property::Value *result = 0 ;
44894
44895   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44896   result = (Dali::Property::Value *)& ((arg1)->second);
44897   jresult = (void *)result;
44898   return jresult;
44899 }
44900
44901
44902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44903   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44904
44905   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44906   {
44907     try {
44908       delete arg1;
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (...) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44920       };
44921     }
44922   }
44923 }
44924
44925
44926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44927   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44928
44929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44930   {
44931     try {
44932       (arg1)->clear();
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44940       };
44941     } catch (...) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44944       };
44945     }
44946   }
44947 }
44948
44949
44950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44951   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44952   Dali::TouchPoint *arg2 = 0 ;
44953
44954   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44955   arg2 = (Dali::TouchPoint *)jarg2;
44956   if (!arg2) {
44957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44958     return ;
44959   }
44960   {
44961     try {
44962       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44963     } catch (std::out_of_range& e) {
44964       {
44965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44966       };
44967     } catch (std::exception& e) {
44968       {
44969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44970       };
44971     } catch (...) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44974       };
44975     }
44976   }
44977 }
44978
44979
44980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44981   unsigned long jresult ;
44982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44983   std::vector< Dali::TouchPoint >::size_type result;
44984
44985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44986   {
44987     try {
44988       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45000       };
45001     }
45002   }
45003   jresult = (unsigned long)result;
45004   return jresult;
45005 }
45006
45007
45008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45009   unsigned long jresult ;
45010   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45011   std::vector< Dali::TouchPoint >::size_type result;
45012
45013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45014   {
45015     try {
45016       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45017     } catch (std::out_of_range& e) {
45018       {
45019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (std::exception& e) {
45022       {
45023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (...) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45028       };
45029     }
45030   }
45031   jresult = (unsigned long)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45037   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45038   std::vector< Dali::TouchPoint >::size_type arg2 ;
45039
45040   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45041   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45042   {
45043     try {
45044       (arg1)->reserve(arg2);
45045     } catch (std::out_of_range& e) {
45046       {
45047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (std::exception& e) {
45050       {
45051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059 }
45060
45061
45062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45063   void * jresult ;
45064   std::vector< Dali::TouchPoint > *result = 0 ;
45065
45066   {
45067     try {
45068       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45069     } catch (std::out_of_range& e) {
45070       {
45071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45072       };
45073     } catch (std::exception& e) {
45074       {
45075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (...) {
45078       {
45079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45080       };
45081     }
45082   }
45083   jresult = (void *)result;
45084   return jresult;
45085 }
45086
45087
45088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45089   void * jresult ;
45090   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45091   std::vector< Dali::TouchPoint > *result = 0 ;
45092
45093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45094   if (!arg1) {
45095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45096     return 0;
45097   }
45098   {
45099     try {
45100       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45101     } catch (std::out_of_range& e) {
45102       {
45103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45104       };
45105     } catch (std::exception& e) {
45106       {
45107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45112       };
45113     }
45114   }
45115   jresult = (void *)result;
45116   return jresult;
45117 }
45118
45119
45120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45121   void * jresult ;
45122   int arg1 ;
45123   std::vector< Dali::TouchPoint > *result = 0 ;
45124
45125   arg1 = (int)jarg1;
45126   {
45127     try {
45128       try {
45129         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45130       }
45131       catch(std::out_of_range &_e) {
45132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45133         return 0;
45134       }
45135
45136     } catch (std::out_of_range& e) {
45137       {
45138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45139       };
45140     } catch (std::exception& e) {
45141       {
45142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45143       };
45144     } catch (...) {
45145       {
45146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45147       };
45148     }
45149   }
45150   jresult = (void *)result;
45151   return jresult;
45152 }
45153
45154
45155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45156   void * jresult ;
45157   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45158   int arg2 ;
45159   SwigValueWrapper< Dali::TouchPoint > result;
45160
45161   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45162   arg2 = (int)jarg2;
45163   {
45164     try {
45165       try {
45166         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45167       }
45168       catch(std::out_of_range &_e) {
45169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45170         return 0;
45171       }
45172
45173     } catch (std::out_of_range& e) {
45174       {
45175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45176       };
45177     } catch (std::exception& e) {
45178       {
45179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45180       };
45181     } catch (...) {
45182       {
45183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45184       };
45185     }
45186   }
45187   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45188   return jresult;
45189 }
45190
45191
45192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45193   void * jresult ;
45194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45195   int arg2 ;
45196   Dali::TouchPoint *result = 0 ;
45197
45198   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45199   arg2 = (int)jarg2;
45200   {
45201     try {
45202       try {
45203         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45204       }
45205       catch(std::out_of_range &_e) {
45206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45207         return 0;
45208       }
45209
45210     } catch (std::out_of_range& e) {
45211       {
45212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45213       };
45214     } catch (std::exception& e) {
45215       {
45216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45217       };
45218     } catch (...) {
45219       {
45220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45221       };
45222     }
45223   }
45224   jresult = (void *)result;
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45230   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45231   int arg2 ;
45232   Dali::TouchPoint *arg3 = 0 ;
45233
45234   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45235   arg2 = (int)jarg2;
45236   arg3 = (Dali::TouchPoint *)jarg3;
45237   if (!arg3) {
45238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45239     return ;
45240   }
45241   {
45242     try {
45243       try {
45244         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45245       }
45246       catch(std::out_of_range &_e) {
45247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45248         return ;
45249       }
45250
45251     } catch (std::out_of_range& e) {
45252       {
45253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45254       };
45255     } catch (std::exception& e) {
45256       {
45257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45258       };
45259     } catch (...) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45262       };
45263     }
45264   }
45265 }
45266
45267
45268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45269   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45270   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45271
45272   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45273   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45274   if (!arg2) {
45275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45276     return ;
45277   }
45278   {
45279     try {
45280       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45281     } catch (std::out_of_range& e) {
45282       {
45283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (std::exception& e) {
45286       {
45287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45292       };
45293     }
45294   }
45295 }
45296
45297
45298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45299   void * jresult ;
45300   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45301   int arg2 ;
45302   int arg3 ;
45303   std::vector< Dali::TouchPoint > *result = 0 ;
45304
45305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45306   arg2 = (int)jarg2;
45307   arg3 = (int)jarg3;
45308   {
45309     try {
45310       try {
45311         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45312       }
45313       catch(std::out_of_range &_e) {
45314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45315         return 0;
45316       }
45317       catch(std::invalid_argument &_e) {
45318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45319         return 0;
45320       }
45321
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45333       };
45334     }
45335   }
45336   jresult = (void *)result;
45337   return jresult;
45338 }
45339
45340
45341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45342   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45343   int arg2 ;
45344   Dali::TouchPoint *arg3 = 0 ;
45345
45346   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45347   arg2 = (int)jarg2;
45348   arg3 = (Dali::TouchPoint *)jarg3;
45349   if (!arg3) {
45350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45351     return ;
45352   }
45353   {
45354     try {
45355       try {
45356         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45357       }
45358       catch(std::out_of_range &_e) {
45359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45360         return ;
45361       }
45362
45363     } catch (std::out_of_range& e) {
45364       {
45365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45366       };
45367     } catch (std::exception& e) {
45368       {
45369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45370       };
45371     } catch (...) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45374       };
45375     }
45376   }
45377 }
45378
45379
45380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45381   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45382   int arg2 ;
45383   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45384
45385   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45386   arg2 = (int)jarg2;
45387   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45388   if (!arg3) {
45389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45390     return ;
45391   }
45392   {
45393     try {
45394       try {
45395         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45396       }
45397       catch(std::out_of_range &_e) {
45398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45399         return ;
45400       }
45401
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45413       };
45414     }
45415   }
45416 }
45417
45418
45419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45420   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45421   int arg2 ;
45422
45423   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45424   arg2 = (int)jarg2;
45425   {
45426     try {
45427       try {
45428         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45429       }
45430       catch(std::out_of_range &_e) {
45431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45432         return ;
45433       }
45434
45435     } catch (std::out_of_range& e) {
45436       {
45437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45438       };
45439     } catch (std::exception& e) {
45440       {
45441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45442       };
45443     } catch (...) {
45444       {
45445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45446       };
45447     }
45448   }
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45454   int arg2 ;
45455   int arg3 ;
45456
45457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45458   arg2 = (int)jarg2;
45459   arg3 = (int)jarg3;
45460   {
45461     try {
45462       try {
45463         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45464       }
45465       catch(std::out_of_range &_e) {
45466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45467         return ;
45468       }
45469       catch(std::invalid_argument &_e) {
45470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45471         return ;
45472       }
45473
45474     } catch (std::out_of_range& e) {
45475       {
45476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45477       };
45478     } catch (std::exception& e) {
45479       {
45480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45485       };
45486     }
45487   }
45488 }
45489
45490
45491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45492   void * jresult ;
45493   Dali::TouchPoint *arg1 = 0 ;
45494   int arg2 ;
45495   std::vector< Dali::TouchPoint > *result = 0 ;
45496
45497   arg1 = (Dali::TouchPoint *)jarg1;
45498   if (!arg1) {
45499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45500     return 0;
45501   }
45502   arg2 = (int)jarg2;
45503   {
45504     try {
45505       try {
45506         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45507       }
45508       catch(std::out_of_range &_e) {
45509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45510         return 0;
45511       }
45512
45513     } catch (std::out_of_range& e) {
45514       {
45515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45516       };
45517     } catch (std::exception& e) {
45518       {
45519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45520       };
45521     } catch (...) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45524       };
45525     }
45526   }
45527   jresult = (void *)result;
45528   return jresult;
45529 }
45530
45531
45532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45533   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45534
45535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45536   {
45537     try {
45538       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (...) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45550       };
45551     }
45552   }
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45557   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45558   int arg2 ;
45559   int arg3 ;
45560
45561   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45562   arg2 = (int)jarg2;
45563   arg3 = (int)jarg3;
45564   {
45565     try {
45566       try {
45567         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45568       }
45569       catch(std::out_of_range &_e) {
45570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45571         return ;
45572       }
45573       catch(std::invalid_argument &_e) {
45574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45575         return ;
45576       }
45577
45578     } catch (std::out_of_range& e) {
45579       {
45580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45581       };
45582     } catch (std::exception& e) {
45583       {
45584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45585       };
45586     } catch (...) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45589       };
45590     }
45591   }
45592 }
45593
45594
45595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45596   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45597   int arg2 ;
45598   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45599
45600   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45601   arg2 = (int)jarg2;
45602   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45603   if (!arg3) {
45604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45605     return ;
45606   }
45607   {
45608     try {
45609       try {
45610         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45611       }
45612       catch(std::out_of_range &_e) {
45613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45614         return ;
45615       }
45616
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45628       };
45629     }
45630   }
45631 }
45632
45633
45634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45635   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45636
45637   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45638   {
45639     try {
45640       delete arg1;
45641     } catch (std::out_of_range& e) {
45642       {
45643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45644       };
45645     } catch (std::exception& e) {
45646       {
45647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45648       };
45649     } catch (...) {
45650       {
45651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45652       };
45653     }
45654   }
45655 }
45656
45657
45658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45659   void * jresult ;
45660   Dali::Rect< int > *result = 0 ;
45661
45662   {
45663     try {
45664       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679   jresult = (void *)result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45685   void * jresult ;
45686   int arg1 ;
45687   int arg2 ;
45688   int arg3 ;
45689   int arg4 ;
45690   Dali::Rect< int > *result = 0 ;
45691
45692   arg1 = (int)jarg1;
45693   arg2 = (int)jarg2;
45694   arg3 = (int)jarg3;
45695   arg4 = (int)jarg4;
45696   {
45697     try {
45698       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45699     } catch (std::out_of_range& e) {
45700       {
45701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45702       };
45703     } catch (std::exception& e) {
45704       {
45705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45710       };
45711     }
45712   }
45713   jresult = (void *)result;
45714   return jresult;
45715 }
45716
45717
45718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45719   void * jresult ;
45720   Dali::Rect< int > *arg1 = 0 ;
45721   Dali::Rect< int > *result = 0 ;
45722
45723   arg1 = (Dali::Rect< int > *)jarg1;
45724   if (!arg1) {
45725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45726     return 0;
45727   }
45728   {
45729     try {
45730       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45731     } catch (std::out_of_range& e) {
45732       {
45733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45734       };
45735     } catch (std::exception& e) {
45736       {
45737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45738       };
45739     } catch (...) {
45740       {
45741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45742       };
45743     }
45744   }
45745   jresult = (void *)result;
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45751   void * jresult ;
45752   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45753   Dali::Rect< int > *arg2 = 0 ;
45754   Dali::Rect< int > *result = 0 ;
45755
45756   arg1 = (Dali::Rect< int > *)jarg1;
45757   arg2 = (Dali::Rect< int > *)jarg2;
45758   if (!arg2) {
45759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45760     return 0;
45761   }
45762   {
45763     try {
45764       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45765     } catch (std::out_of_range& e) {
45766       {
45767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (std::exception& e) {
45770       {
45771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779   jresult = (void *)result;
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45785   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45786   int arg2 ;
45787   int arg3 ;
45788   int arg4 ;
45789   int arg5 ;
45790
45791   arg1 = (Dali::Rect< int > *)jarg1;
45792   arg2 = (int)jarg2;
45793   arg3 = (int)jarg3;
45794   arg4 = (int)jarg4;
45795   arg5 = (int)jarg5;
45796   {
45797     try {
45798       (arg1)->Set(arg2,arg3,arg4,arg5);
45799     } catch (std::out_of_range& e) {
45800       {
45801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45802       };
45803     } catch (std::exception& e) {
45804       {
45805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45810       };
45811     }
45812   }
45813 }
45814
45815
45816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45817   unsigned int jresult ;
45818   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45819   bool result;
45820
45821   arg1 = (Dali::Rect< int > *)jarg1;
45822   {
45823     try {
45824       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (...) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45836       };
45837     }
45838   }
45839   jresult = result;
45840   return jresult;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45845   int jresult ;
45846   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45847   int result;
45848
45849   arg1 = (Dali::Rect< int > *)jarg1;
45850   {
45851     try {
45852       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (...) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45864       };
45865     }
45866   }
45867   jresult = result;
45868   return jresult;
45869 }
45870
45871
45872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45873   int jresult ;
45874   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45875   int result;
45876
45877   arg1 = (Dali::Rect< int > *)jarg1;
45878   {
45879     try {
45880       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45881     } catch (std::out_of_range& e) {
45882       {
45883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45884       };
45885     } catch (std::exception& e) {
45886       {
45887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45892       };
45893     }
45894   }
45895   jresult = result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45901   int jresult ;
45902   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45903   int result;
45904
45905   arg1 = (Dali::Rect< int > *)jarg1;
45906   {
45907     try {
45908       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (...) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45920       };
45921     }
45922   }
45923   jresult = result;
45924   return jresult;
45925 }
45926
45927
45928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45929   int jresult ;
45930   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45931   int result;
45932
45933   arg1 = (Dali::Rect< int > *)jarg1;
45934   {
45935     try {
45936       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45937     } catch (std::out_of_range& e) {
45938       {
45939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45940       };
45941     } catch (std::exception& e) {
45942       {
45943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45944       };
45945     } catch (...) {
45946       {
45947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45948       };
45949     }
45950   }
45951   jresult = result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45957   int jresult ;
45958   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45959   int result;
45960
45961   arg1 = (Dali::Rect< int > *)jarg1;
45962   {
45963     try {
45964       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45965     } catch (std::out_of_range& e) {
45966       {
45967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45968       };
45969     } catch (std::exception& e) {
45970       {
45971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45972       };
45973     } catch (...) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45976       };
45977     }
45978   }
45979   jresult = result;
45980   return jresult;
45981 }
45982
45983
45984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45985   unsigned int jresult ;
45986   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45987   Dali::Rect< int > *arg2 = 0 ;
45988   bool result;
45989
45990   arg1 = (Dali::Rect< int > *)jarg1;
45991   arg2 = (Dali::Rect< int > *)jarg2;
45992   if (!arg2) {
45993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45994     return 0;
45995   }
45996   {
45997     try {
45998       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45999     } catch (std::out_of_range& e) {
46000       {
46001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46002       };
46003     } catch (std::exception& e) {
46004       {
46005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46006       };
46007     } catch (...) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46010       };
46011     }
46012   }
46013   jresult = result;
46014   return jresult;
46015 }
46016
46017
46018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46019   unsigned int jresult ;
46020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46021   Dali::Rect< int > *arg2 = 0 ;
46022   bool result;
46023
46024   arg1 = (Dali::Rect< int > *)jarg1;
46025   arg2 = (Dali::Rect< int > *)jarg2;
46026   if (!arg2) {
46027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46028     return 0;
46029   }
46030   {
46031     try {
46032       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46033     } catch (std::out_of_range& e) {
46034       {
46035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46036       };
46037     } catch (std::exception& e) {
46038       {
46039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (...) {
46042       {
46043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46044       };
46045     }
46046   }
46047   jresult = result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
46053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46054   int arg2 ;
46055
46056   arg1 = (Dali::Rect< int > *)jarg1;
46057   arg2 = (int)jarg2;
46058   if (arg1) (arg1)->x = arg2;
46059 }
46060
46061
46062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
46063   int jresult ;
46064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46065   int result;
46066
46067   arg1 = (Dali::Rect< int > *)jarg1;
46068   result = (int) ((arg1)->x);
46069   jresult = result;
46070   return jresult;
46071 }
46072
46073
46074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
46075   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46076   int arg2 ;
46077
46078   arg1 = (Dali::Rect< int > *)jarg1;
46079   arg2 = (int)jarg2;
46080   if (arg1) (arg1)->left = arg2;
46081 }
46082
46083
46084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46085   int jresult ;
46086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46087   int result;
46088
46089   arg1 = (Dali::Rect< int > *)jarg1;
46090   result = (int) ((arg1)->left);
46091   jresult = result;
46092   return jresult;
46093 }
46094
46095
46096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46098   int arg2 ;
46099
46100   arg1 = (Dali::Rect< int > *)jarg1;
46101   arg2 = (int)jarg2;
46102   if (arg1) (arg1)->y = arg2;
46103 }
46104
46105
46106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46107   int jresult ;
46108   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46109   int result;
46110
46111   arg1 = (Dali::Rect< int > *)jarg1;
46112   result = (int) ((arg1)->y);
46113   jresult = result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46120   int arg2 ;
46121
46122   arg1 = (Dali::Rect< int > *)jarg1;
46123   arg2 = (int)jarg2;
46124   if (arg1) (arg1)->right = arg2;
46125 }
46126
46127
46128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46129   int jresult ;
46130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46131   int result;
46132
46133   arg1 = (Dali::Rect< int > *)jarg1;
46134   result = (int) ((arg1)->right);
46135   jresult = result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46141   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46142   int arg2 ;
46143
46144   arg1 = (Dali::Rect< int > *)jarg1;
46145   arg2 = (int)jarg2;
46146   if (arg1) (arg1)->width = arg2;
46147 }
46148
46149
46150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46151   int jresult ;
46152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46153   int result;
46154
46155   arg1 = (Dali::Rect< int > *)jarg1;
46156   result = (int) ((arg1)->width);
46157   jresult = result;
46158   return jresult;
46159 }
46160
46161
46162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46164   int arg2 ;
46165
46166   arg1 = (Dali::Rect< int > *)jarg1;
46167   arg2 = (int)jarg2;
46168   if (arg1) (arg1)->bottom = arg2;
46169 }
46170
46171
46172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46173   int jresult ;
46174   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46175   int result;
46176
46177   arg1 = (Dali::Rect< int > *)jarg1;
46178   result = (int) ((arg1)->bottom);
46179   jresult = result;
46180   return jresult;
46181 }
46182
46183
46184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46186   int arg2 ;
46187
46188   arg1 = (Dali::Rect< int > *)jarg1;
46189   arg2 = (int)jarg2;
46190   if (arg1) (arg1)->height = arg2;
46191 }
46192
46193
46194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46195   int jresult ;
46196   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46197   int result;
46198
46199   arg1 = (Dali::Rect< int > *)jarg1;
46200   result = (int) ((arg1)->height);
46201   jresult = result;
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46207   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46208   int arg2 ;
46209
46210   arg1 = (Dali::Rect< int > *)jarg1;
46211   arg2 = (int)jarg2;
46212   if (arg1) (arg1)->top = arg2;
46213 }
46214
46215
46216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46217   int jresult ;
46218   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46219   int result;
46220
46221   arg1 = (Dali::Rect< int > *)jarg1;
46222   result = (int) ((arg1)->top);
46223   jresult = result;
46224   return jresult;
46225 }
46226
46227
46228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46229   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46230
46231   arg1 = (Dali::Rect< int > *)jarg1;
46232   {
46233     try {
46234       delete arg1;
46235     } catch (std::out_of_range& e) {
46236       {
46237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46238       };
46239     } catch (std::exception& e) {
46240       {
46241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46242       };
46243     } catch (...) {
46244       {
46245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46246       };
46247     }
46248   }
46249 }
46250
46251
46252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46253   void * jresult ;
46254   Dali::Rect< float > *result = 0 ;
46255
46256   {
46257     try {
46258       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46270       };
46271     }
46272   }
46273   jresult = (void *)result;
46274   return jresult;
46275 }
46276
46277
46278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46279   void * jresult ;
46280   float arg1 ;
46281   float arg2 ;
46282   float arg3 ;
46283   float arg4 ;
46284   Dali::Rect< float > *result = 0 ;
46285
46286   arg1 = (float)jarg1;
46287   arg2 = (float)jarg2;
46288   arg3 = (float)jarg3;
46289   arg4 = (float)jarg4;
46290   {
46291     try {
46292       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46300       };
46301     } catch (...) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46304       };
46305     }
46306   }
46307   jresult = (void *)result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46313   void * jresult ;
46314   Dali::Rect< float > *arg1 = 0 ;
46315   Dali::Rect< float > *result = 0 ;
46316
46317   arg1 = (Dali::Rect< float > *)jarg1;
46318   if (!arg1) {
46319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46320     return 0;
46321   }
46322   {
46323     try {
46324       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46325     } catch (std::out_of_range& e) {
46326       {
46327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46328       };
46329     } catch (std::exception& e) {
46330       {
46331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46332       };
46333     } catch (...) {
46334       {
46335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46336       };
46337     }
46338   }
46339   jresult = (void *)result;
46340   return jresult;
46341 }
46342
46343
46344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46345   void * jresult ;
46346   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46347   Dali::Rect< float > *arg2 = 0 ;
46348   Dali::Rect< float > *result = 0 ;
46349
46350   arg1 = (Dali::Rect< float > *)jarg1;
46351   arg2 = (Dali::Rect< float > *)jarg2;
46352   if (!arg2) {
46353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46354     return 0;
46355   }
46356   {
46357     try {
46358       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46359     } catch (std::out_of_range& e) {
46360       {
46361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46362       };
46363     } catch (std::exception& e) {
46364       {
46365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46366       };
46367     } catch (...) {
46368       {
46369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46370       };
46371     }
46372   }
46373   jresult = (void *)result;
46374   return jresult;
46375 }
46376
46377
46378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46379   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46380   float arg2 ;
46381   float arg3 ;
46382   float arg4 ;
46383   float arg5 ;
46384
46385   arg1 = (Dali::Rect< float > *)jarg1;
46386   arg2 = (float)jarg2;
46387   arg3 = (float)jarg3;
46388   arg4 = (float)jarg4;
46389   arg5 = (float)jarg5;
46390   {
46391     try {
46392       (arg1)->Set(arg2,arg3,arg4,arg5);
46393     } catch (std::out_of_range& e) {
46394       {
46395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46396       };
46397     } catch (std::exception& e) {
46398       {
46399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46400       };
46401     } catch (...) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46404       };
46405     }
46406   }
46407 }
46408
46409
46410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46411   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46412   float arg2 ;
46413
46414   arg1 = (Dali::Rect< float > *)jarg1;
46415   arg2 = (float)jarg2;
46416   if (arg1) (arg1)->x = arg2;
46417 }
46418
46419
46420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46421   float jresult ;
46422   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46423   float result;
46424
46425   arg1 = (Dali::Rect< float > *)jarg1;
46426   result = (float) ((arg1)->x);
46427   jresult = result;
46428   return jresult;
46429 }
46430
46431
46432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46433   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46434   float arg2 ;
46435
46436   arg1 = (Dali::Rect< float > *)jarg1;
46437   arg2 = (float)jarg2;
46438   if (arg1) (arg1)->left = arg2;
46439 }
46440
46441
46442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46443   float jresult ;
46444   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46445   float result;
46446
46447   arg1 = (Dali::Rect< float > *)jarg1;
46448   result = (float) ((arg1)->left);
46449   jresult = result;
46450   return jresult;
46451 }
46452
46453
46454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46455   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46456   float arg2 ;
46457
46458   arg1 = (Dali::Rect< float > *)jarg1;
46459   arg2 = (float)jarg2;
46460   if (arg1) (arg1)->y = arg2;
46461 }
46462
46463
46464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46465   float jresult ;
46466   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46467   float result;
46468
46469   arg1 = (Dali::Rect< float > *)jarg1;
46470   result = (float) ((arg1)->y);
46471   jresult = result;
46472   return jresult;
46473 }
46474
46475
46476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46477   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46478   float arg2 ;
46479
46480   arg1 = (Dali::Rect< float > *)jarg1;
46481   arg2 = (float)jarg2;
46482   if (arg1) (arg1)->right = arg2;
46483 }
46484
46485
46486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46487   float jresult ;
46488   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46489   float result;
46490
46491   arg1 = (Dali::Rect< float > *)jarg1;
46492   result = (float) ((arg1)->right);
46493   jresult = result;
46494   return jresult;
46495 }
46496
46497
46498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46500   float arg2 ;
46501
46502   arg1 = (Dali::Rect< float > *)jarg1;
46503   arg2 = (float)jarg2;
46504   if (arg1) (arg1)->width = arg2;
46505 }
46506
46507
46508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46509   float jresult ;
46510   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46511   float result;
46512
46513   arg1 = (Dali::Rect< float > *)jarg1;
46514   result = (float) ((arg1)->width);
46515   jresult = result;
46516   return jresult;
46517 }
46518
46519
46520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46522   float arg2 ;
46523
46524   arg1 = (Dali::Rect< float > *)jarg1;
46525   arg2 = (float)jarg2;
46526   if (arg1) (arg1)->bottom = arg2;
46527 }
46528
46529
46530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46531   float jresult ;
46532   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46533   float result;
46534
46535   arg1 = (Dali::Rect< float > *)jarg1;
46536   result = (float) ((arg1)->bottom);
46537   jresult = result;
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46543   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46544   float arg2 ;
46545
46546   arg1 = (Dali::Rect< float > *)jarg1;
46547   arg2 = (float)jarg2;
46548   if (arg1) (arg1)->height = arg2;
46549 }
46550
46551
46552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46553   float jresult ;
46554   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46555   float result;
46556
46557   arg1 = (Dali::Rect< float > *)jarg1;
46558   result = (float) ((arg1)->height);
46559   jresult = result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46565   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46566   float arg2 ;
46567
46568   arg1 = (Dali::Rect< float > *)jarg1;
46569   arg2 = (float)jarg2;
46570   if (arg1) (arg1)->top = arg2;
46571 }
46572
46573
46574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46575   float jresult ;
46576   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46577   float result;
46578
46579   arg1 = (Dali::Rect< float > *)jarg1;
46580   result = (float) ((arg1)->top);
46581   jresult = result;
46582   return jresult;
46583 }
46584
46585
46586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46587   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46588
46589   arg1 = (Dali::Rect< float > *)jarg1;
46590   {
46591     try {
46592       delete arg1;
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46600       };
46601     } catch (...) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46604       };
46605     }
46606   }
46607 }
46608
46609
46610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46611   int jresult ;
46612   int result;
46613
46614   result = (int)Dali::Vector< int >::BaseType;
46615   jresult = (int)result;
46616   return jresult;
46617 }
46618
46619
46620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46621   void * jresult ;
46622   Dali::Vector< int > *result = 0 ;
46623
46624   {
46625     try {
46626       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46627     } catch (std::out_of_range& e) {
46628       {
46629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (std::exception& e) {
46632       {
46633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641   jresult = (void *)result;
46642   return jresult;
46643 }
46644
46645
46646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46647   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46648
46649   arg1 = (Dali::Vector< int > *)jarg1;
46650   {
46651     try {
46652       delete arg1;
46653     } catch (std::out_of_range& e) {
46654       {
46655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46656       };
46657     } catch (std::exception& e) {
46658       {
46659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46660       };
46661     } catch (...) {
46662       {
46663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46664       };
46665     }
46666   }
46667 }
46668
46669
46670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46671   void * jresult ;
46672   Dali::Vector< int > *arg1 = 0 ;
46673   Dali::Vector< int > *result = 0 ;
46674
46675   arg1 = (Dali::Vector< int > *)jarg1;
46676   if (!arg1) {
46677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46678     return 0;
46679   }
46680   {
46681     try {
46682       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (...) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46694       };
46695     }
46696   }
46697   jresult = (void *)result;
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46703   void * jresult ;
46704   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46705   Dali::Vector< int > *arg2 = 0 ;
46706   Dali::Vector< int > *result = 0 ;
46707
46708   arg1 = (Dali::Vector< int > *)jarg1;
46709   arg2 = (Dali::Vector< int > *)jarg2;
46710   if (!arg2) {
46711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46712     return 0;
46713   }
46714   {
46715     try {
46716       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46717     } catch (std::out_of_range& e) {
46718       {
46719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46720       };
46721     } catch (std::exception& e) {
46722       {
46723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46724       };
46725     } catch (...) {
46726       {
46727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46728       };
46729     }
46730   }
46731   jresult = (void *)result;
46732   return jresult;
46733 }
46734
46735
46736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46737   void * jresult ;
46738   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46739   Dali::Vector< int >::Iterator result;
46740
46741   arg1 = (Dali::Vector< int > *)jarg1;
46742   {
46743     try {
46744       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46745     } catch (std::out_of_range& e) {
46746       {
46747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46748       };
46749     } catch (std::exception& e) {
46750       {
46751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46752       };
46753     } catch (...) {
46754       {
46755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46756       };
46757     }
46758   }
46759   jresult = (void *)result;
46760   return jresult;
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46765   void * jresult ;
46766   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46767   Dali::Vector< int >::Iterator result;
46768
46769   arg1 = (Dali::Vector< int > *)jarg1;
46770   {
46771     try {
46772       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46784       };
46785     }
46786   }
46787   jresult = (void *)result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46793   void * jresult ;
46794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46795   Dali::Vector< int >::SizeType arg2 ;
46796   Dali::Vector< int >::ItemType *result = 0 ;
46797
46798   arg1 = (Dali::Vector< int > *)jarg1;
46799   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46800   {
46801     try {
46802       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46803     } catch (std::out_of_range& e) {
46804       {
46805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46806       };
46807     } catch (std::exception& e) {
46808       {
46809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46810       };
46811     } catch (...) {
46812       {
46813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46814       };
46815     }
46816   }
46817   jresult = (void *)result;
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46823   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46824   Dali::Vector< int >::ItemType *arg2 = 0 ;
46825   Dali::Vector< int >::ItemType temp2 ;
46826
46827   arg1 = (Dali::Vector< int > *)jarg1;
46828   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46829   arg2 = &temp2;
46830   {
46831     try {
46832       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46833     } catch (std::out_of_range& e) {
46834       {
46835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46836       };
46837     } catch (std::exception& e) {
46838       {
46839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46840       };
46841     } catch (...) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46844       };
46845     }
46846   }
46847 }
46848
46849
46850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46851   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46852   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46853   Dali::Vector< int >::ItemType *arg3 = 0 ;
46854   Dali::Vector< int >::ItemType temp3 ;
46855
46856   arg1 = (Dali::Vector< int > *)jarg1;
46857   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46858   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46859   arg3 = &temp3;
46860   {
46861     try {
46862       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (...) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46874       };
46875     }
46876   }
46877 }
46878
46879
46880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46881   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46882   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46883   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46884   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46885
46886   arg1 = (Dali::Vector< int > *)jarg1;
46887   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46888   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46889   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46890   {
46891     try {
46892       (arg1)->Insert(arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46900       };
46901     } catch (...) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46904       };
46905     }
46906   }
46907 }
46908
46909
46910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46911   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46912   Dali::Vector< int >::SizeType arg2 ;
46913
46914   arg1 = (Dali::Vector< int > *)jarg1;
46915   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46916   {
46917     try {
46918       (arg1)->Reserve(arg2);
46919     } catch (std::out_of_range& e) {
46920       {
46921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46922       };
46923     } catch (std::exception& e) {
46924       {
46925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46926       };
46927     } catch (...) {
46928       {
46929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46930       };
46931     }
46932   }
46933 }
46934
46935
46936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46937   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46938   Dali::Vector< int >::SizeType arg2 ;
46939
46940   arg1 = (Dali::Vector< int > *)jarg1;
46941   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46942   {
46943     try {
46944       (arg1)->Resize(arg2);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46952       };
46953     } catch (...) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46956       };
46957     }
46958   }
46959 }
46960
46961
46962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46963   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46964   Dali::Vector< int >::SizeType arg2 ;
46965   Dali::Vector< int >::ItemType *arg3 = 0 ;
46966   Dali::Vector< int >::ItemType temp3 ;
46967
46968   arg1 = (Dali::Vector< int > *)jarg1;
46969   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46970   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46971   arg3 = &temp3;
46972   {
46973     try {
46974       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46975     } catch (std::out_of_range& e) {
46976       {
46977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46978       };
46979     } catch (std::exception& e) {
46980       {
46981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46982       };
46983     } catch (...) {
46984       {
46985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46986       };
46987     }
46988   }
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46993   void * jresult ;
46994   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46995   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46996   Dali::Vector< int >::Iterator result;
46997
46998   arg1 = (Dali::Vector< int > *)jarg1;
46999   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47000   {
47001     try {
47002       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (...) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47014       };
47015     }
47016   }
47017   jresult = (void *)result;
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47023   void * jresult ;
47024   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47025   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47026   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47027   Dali::Vector< int >::Iterator result;
47028
47029   arg1 = (Dali::Vector< int > *)jarg1;
47030   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47031   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47032   {
47033     try {
47034       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (...) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47046       };
47047     }
47048   }
47049   jresult = (void *)result;
47050   return jresult;
47051 }
47052
47053
47054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
47055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47056   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47057
47058   arg1 = (Dali::Vector< int > *)jarg1;
47059   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47060   {
47061     try {
47062       (arg1)->Remove(arg2);
47063     } catch (std::out_of_range& e) {
47064       {
47065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47066       };
47067     } catch (std::exception& e) {
47068       {
47069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47070       };
47071     } catch (...) {
47072       {
47073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47074       };
47075     }
47076   }
47077 }
47078
47079
47080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47081   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47082   Dali::Vector< int > *arg2 = 0 ;
47083
47084   arg1 = (Dali::Vector< int > *)jarg1;
47085   arg2 = (Dali::Vector< int > *)jarg2;
47086   if (!arg2) {
47087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47088     return ;
47089   }
47090   {
47091     try {
47092       (arg1)->Swap(*arg2);
47093     } catch (std::out_of_range& e) {
47094       {
47095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47096       };
47097     } catch (std::exception& e) {
47098       {
47099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47100       };
47101     } catch (...) {
47102       {
47103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47104       };
47105     }
47106   }
47107 }
47108
47109
47110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47111   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47112
47113   arg1 = (Dali::Vector< int > *)jarg1;
47114   {
47115     try {
47116       (arg1)->Clear();
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (...) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47128       };
47129     }
47130   }
47131 }
47132
47133
47134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47135   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47136
47137   arg1 = (Dali::Vector< int > *)jarg1;
47138   {
47139     try {
47140       (arg1)->Release();
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47152       };
47153     }
47154   }
47155 }
47156
47157
47158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47159   int jresult ;
47160   int result;
47161
47162   result = (int)Dali::Vector< float >::BaseType;
47163   jresult = (int)result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47169   void * jresult ;
47170   Dali::Vector< float > *result = 0 ;
47171
47172   {
47173     try {
47174       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (...) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47186       };
47187     }
47188   }
47189   jresult = (void *)result;
47190   return jresult;
47191 }
47192
47193
47194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47195   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47196
47197   arg1 = (Dali::Vector< float > *)jarg1;
47198   {
47199     try {
47200       delete arg1;
47201     } catch (std::out_of_range& e) {
47202       {
47203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47204       };
47205     } catch (std::exception& e) {
47206       {
47207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (...) {
47210       {
47211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47212       };
47213     }
47214   }
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47219   void * jresult ;
47220   Dali::Vector< float > *arg1 = 0 ;
47221   Dali::Vector< float > *result = 0 ;
47222
47223   arg1 = (Dali::Vector< float > *)jarg1;
47224   if (!arg1) {
47225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47226     return 0;
47227   }
47228   {
47229     try {
47230       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245   jresult = (void *)result;
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47251   void * jresult ;
47252   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47253   Dali::Vector< float > *arg2 = 0 ;
47254   Dali::Vector< float > *result = 0 ;
47255
47256   arg1 = (Dali::Vector< float > *)jarg1;
47257   arg2 = (Dali::Vector< float > *)jarg2;
47258   if (!arg2) {
47259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47260     return 0;
47261   }
47262   {
47263     try {
47264       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47265     } catch (std::out_of_range& e) {
47266       {
47267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (std::exception& e) {
47270       {
47271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47272       };
47273     } catch (...) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47276       };
47277     }
47278   }
47279   jresult = (void *)result;
47280   return jresult;
47281 }
47282
47283
47284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47285   void * jresult ;
47286   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47287   Dali::Vector< float >::Iterator result;
47288
47289   arg1 = (Dali::Vector< float > *)jarg1;
47290   {
47291     try {
47292       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47293     } catch (std::out_of_range& e) {
47294       {
47295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (std::exception& e) {
47298       {
47299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47300       };
47301     } catch (...) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47304       };
47305     }
47306   }
47307   jresult = (void *)result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47313   void * jresult ;
47314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47315   Dali::Vector< float >::Iterator result;
47316
47317   arg1 = (Dali::Vector< float > *)jarg1;
47318   {
47319     try {
47320       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335   jresult = (void *)result;
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47341   void * jresult ;
47342   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47343   Dali::Vector< float >::SizeType arg2 ;
47344   Dali::Vector< float >::ItemType *result = 0 ;
47345
47346   arg1 = (Dali::Vector< float > *)jarg1;
47347   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47348   {
47349     try {
47350       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47358       };
47359     } catch (...) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47362       };
47363     }
47364   }
47365   jresult = (void *)result;
47366   return jresult;
47367 }
47368
47369
47370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47371   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47372   Dali::Vector< float >::ItemType *arg2 = 0 ;
47373   Dali::Vector< float >::ItemType temp2 ;
47374
47375   arg1 = (Dali::Vector< float > *)jarg1;
47376   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47377   arg2 = &temp2;
47378   {
47379     try {
47380       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47381     } catch (std::out_of_range& e) {
47382       {
47383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47384       };
47385     } catch (std::exception& e) {
47386       {
47387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47388       };
47389     } catch (...) {
47390       {
47391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47392       };
47393     }
47394   }
47395 }
47396
47397
47398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47399   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47400   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47401   Dali::Vector< float >::ItemType *arg3 = 0 ;
47402   Dali::Vector< float >::ItemType temp3 ;
47403
47404   arg1 = (Dali::Vector< float > *)jarg1;
47405   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47406   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47407   arg3 = &temp3;
47408   {
47409     try {
47410       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47411     } catch (std::out_of_range& e) {
47412       {
47413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47414       };
47415     } catch (std::exception& e) {
47416       {
47417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47418       };
47419     } catch (...) {
47420       {
47421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47422       };
47423     }
47424   }
47425 }
47426
47427
47428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47429   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47430   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47431   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47432   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47433
47434   arg1 = (Dali::Vector< float > *)jarg1;
47435   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47436   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47437   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47438   {
47439     try {
47440       (arg1)->Insert(arg2,arg3,arg4);
47441     } catch (std::out_of_range& e) {
47442       {
47443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47444       };
47445     } catch (std::exception& e) {
47446       {
47447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47448       };
47449     } catch (...) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47452       };
47453     }
47454   }
47455 }
47456
47457
47458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47460   Dali::Vector< float >::SizeType arg2 ;
47461
47462   arg1 = (Dali::Vector< float > *)jarg1;
47463   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47464   {
47465     try {
47466       (arg1)->Reserve(arg2);
47467     } catch (std::out_of_range& e) {
47468       {
47469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47470       };
47471     } catch (std::exception& e) {
47472       {
47473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47474       };
47475     } catch (...) {
47476       {
47477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47478       };
47479     }
47480   }
47481 }
47482
47483
47484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47485   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47486   Dali::Vector< float >::SizeType arg2 ;
47487
47488   arg1 = (Dali::Vector< float > *)jarg1;
47489   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47490   {
47491     try {
47492       (arg1)->Resize(arg2);
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47504       };
47505     }
47506   }
47507 }
47508
47509
47510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47511   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47512   Dali::Vector< float >::SizeType arg2 ;
47513   Dali::Vector< float >::ItemType *arg3 = 0 ;
47514   Dali::Vector< float >::ItemType temp3 ;
47515
47516   arg1 = (Dali::Vector< float > *)jarg1;
47517   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47518   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47519   arg3 = &temp3;
47520   {
47521     try {
47522       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (...) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47534       };
47535     }
47536   }
47537 }
47538
47539
47540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47541   void * jresult ;
47542   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47543   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47544   Dali::Vector< float >::Iterator result;
47545
47546   arg1 = (Dali::Vector< float > *)jarg1;
47547   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47548   {
47549     try {
47550       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47551     } catch (std::out_of_range& e) {
47552       {
47553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47554       };
47555     } catch (std::exception& e) {
47556       {
47557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47558       };
47559     } catch (...) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47562       };
47563     }
47564   }
47565   jresult = (void *)result;
47566   return jresult;
47567 }
47568
47569
47570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47571   void * jresult ;
47572   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47573   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47574   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47575   Dali::Vector< float >::Iterator result;
47576
47577   arg1 = (Dali::Vector< float > *)jarg1;
47578   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47579   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47580   {
47581     try {
47582       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47603   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47604   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47605
47606   arg1 = (Dali::Vector< float > *)jarg1;
47607   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47608   {
47609     try {
47610       (arg1)->Remove(arg2);
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47618       };
47619     } catch (...) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47622       };
47623     }
47624   }
47625 }
47626
47627
47628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47629   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47630   Dali::Vector< float > *arg2 = 0 ;
47631
47632   arg1 = (Dali::Vector< float > *)jarg1;
47633   arg2 = (Dali::Vector< float > *)jarg2;
47634   if (!arg2) {
47635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47636     return ;
47637   }
47638   {
47639     try {
47640       (arg1)->Swap(*arg2);
47641     } catch (std::out_of_range& e) {
47642       {
47643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47644       };
47645     } catch (std::exception& e) {
47646       {
47647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47652       };
47653     }
47654   }
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47659   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47660
47661   arg1 = (Dali::Vector< float > *)jarg1;
47662   {
47663     try {
47664       (arg1)->Clear();
47665     } catch (std::out_of_range& e) {
47666       {
47667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47668       };
47669     } catch (std::exception& e) {
47670       {
47671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47676       };
47677     }
47678   }
47679 }
47680
47681
47682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47683   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47684
47685   arg1 = (Dali::Vector< float > *)jarg1;
47686   {
47687     try {
47688       (arg1)->Release();
47689     } catch (std::out_of_range& e) {
47690       {
47691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47692       };
47693     } catch (std::exception& e) {
47694       {
47695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47700       };
47701     }
47702   }
47703 }
47704
47705
47706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47707   int jresult ;
47708   int result;
47709
47710   result = (int)Dali::Vector< unsigned char >::BaseType;
47711   jresult = (int)result;
47712   return jresult;
47713 }
47714
47715
47716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47717   void * jresult ;
47718   Dali::Vector< unsigned char > *result = 0 ;
47719
47720   {
47721     try {
47722       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47723     } catch (std::out_of_range& e) {
47724       {
47725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47726       };
47727     } catch (std::exception& e) {
47728       {
47729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (...) {
47732       {
47733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47734       };
47735     }
47736   }
47737   jresult = (void *)result;
47738   return jresult;
47739 }
47740
47741
47742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47743   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47744
47745   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47746   {
47747     try {
47748       delete arg1;
47749     } catch (std::out_of_range& e) {
47750       {
47751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47752       };
47753     } catch (std::exception& e) {
47754       {
47755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47756       };
47757     } catch (...) {
47758       {
47759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47760       };
47761     }
47762   }
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47767   void * jresult ;
47768   Dali::Vector< unsigned char > *arg1 = 0 ;
47769   Dali::Vector< unsigned char > *result = 0 ;
47770
47771   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47772   if (!arg1) {
47773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47774     return 0;
47775   }
47776   {
47777     try {
47778       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47779     } catch (std::out_of_range& e) {
47780       {
47781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (std::exception& e) {
47784       {
47785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47790       };
47791     }
47792   }
47793   jresult = (void *)result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47799   void * jresult ;
47800   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47801   Dali::Vector< unsigned char > *arg2 = 0 ;
47802   Dali::Vector< unsigned char > *result = 0 ;
47803
47804   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47805   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47806   if (!arg2) {
47807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47808     return 0;
47809   }
47810   {
47811     try {
47812       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47813     } catch (std::out_of_range& e) {
47814       {
47815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (std::exception& e) {
47818       {
47819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47833   void * jresult ;
47834   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47835   Dali::Vector< unsigned char >::Iterator result;
47836
47837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47838   {
47839     try {
47840       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47841     } catch (std::out_of_range& e) {
47842       {
47843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47844       };
47845     } catch (std::exception& e) {
47846       {
47847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (...) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47852       };
47853     }
47854   }
47855   jresult = (void *)result;
47856   return jresult;
47857 }
47858
47859
47860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47861   void * jresult ;
47862   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47863   Dali::Vector< unsigned char >::Iterator result;
47864
47865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47866   {
47867     try {
47868       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47869     } catch (std::out_of_range& e) {
47870       {
47871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (std::exception& e) {
47874       {
47875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883   jresult = (void *)result;
47884   return jresult;
47885 }
47886
47887
47888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47889   void * jresult ;
47890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47891   Dali::Vector< unsigned char >::SizeType arg2 ;
47892   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47893
47894   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47895   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47896   {
47897     try {
47898       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47899     } catch (std::out_of_range& e) {
47900       {
47901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47902       };
47903     } catch (std::exception& e) {
47904       {
47905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (...) {
47908       {
47909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47910       };
47911     }
47912   }
47913   jresult = (void *)result;
47914   return jresult;
47915 }
47916
47917
47918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47919   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47920   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47921   Dali::Vector< unsigned char >::ItemType temp2 ;
47922
47923   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47924   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47925   arg2 = &temp2;
47926   {
47927     try {
47928       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47929     } catch (std::out_of_range& e) {
47930       {
47931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47932       };
47933     } catch (std::exception& e) {
47934       {
47935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47940       };
47941     }
47942   }
47943 }
47944
47945
47946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47947   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47948   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47949   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47950   Dali::Vector< unsigned char >::ItemType temp3 ;
47951
47952   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47953   arg2 = jarg2;
47954   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47955   arg3 = &temp3;
47956   {
47957     try {
47958       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47959     } catch (std::out_of_range& e) {
47960       {
47961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47962       };
47963     } catch (std::exception& e) {
47964       {
47965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47966       };
47967     } catch (...) {
47968       {
47969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47970       };
47971     }
47972   }
47973
47974
47975 }
47976
47977
47978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47980   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47981   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47982   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47983
47984   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47985   arg2 = jarg2;
47986   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47987   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47988   {
47989     try {
47990       (arg1)->Insert(arg2,arg3,arg4);
47991     } catch (std::out_of_range& e) {
47992       {
47993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (std::exception& e) {
47996       {
47997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (...) {
48000       {
48001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48002       };
48003     }
48004   }
48005
48006
48007 }
48008
48009
48010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
48011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48012   Dali::Vector< unsigned char >::SizeType arg2 ;
48013
48014   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48015   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48016   {
48017     try {
48018       (arg1)->Reserve(arg2);
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48030       };
48031     }
48032   }
48033 }
48034
48035
48036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48037   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48038   Dali::Vector< unsigned char >::SizeType arg2 ;
48039
48040   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48041   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48042   {
48043     try {
48044       (arg1)->Resize(arg2);
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48056       };
48057     }
48058   }
48059 }
48060
48061
48062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
48063   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48064   Dali::Vector< unsigned char >::SizeType arg2 ;
48065   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48066   Dali::Vector< unsigned char >::ItemType temp3 ;
48067
48068   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48069   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48070   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48071   arg3 = &temp3;
48072   {
48073     try {
48074       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48075     } catch (std::out_of_range& e) {
48076       {
48077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48078       };
48079     } catch (std::exception& e) {
48080       {
48081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48082       };
48083     } catch (...) {
48084       {
48085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48086       };
48087     }
48088   }
48089 }
48090
48091
48092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48093   void * jresult ;
48094   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48095   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48096   Dali::Vector< unsigned char >::Iterator result;
48097
48098   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48099   arg2 = jarg2;
48100   {
48101     try {
48102       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48103     } catch (std::out_of_range& e) {
48104       {
48105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48106       };
48107     } catch (std::exception& e) {
48108       {
48109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (...) {
48112       {
48113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48114       };
48115     }
48116   }
48117   jresult = (void *)result;
48118
48119
48120   return jresult;
48121 }
48122
48123
48124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48125   void * jresult ;
48126   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48127   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48128   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48129   Dali::Vector< unsigned char >::Iterator result;
48130
48131   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48132   arg2 = jarg2;
48133   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48134   {
48135     try {
48136       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (...) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48148       };
48149     }
48150   }
48151   jresult = (void *)result;
48152
48153
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48159   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48160   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48161
48162   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48163   arg2 = jarg2;
48164   {
48165     try {
48166       (arg1)->Remove(arg2);
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (...) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48178       };
48179     }
48180   }
48181
48182
48183 }
48184
48185
48186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48187   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48188   Dali::Vector< unsigned char > *arg2 = 0 ;
48189
48190   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48191   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48192   if (!arg2) {
48193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48194     return ;
48195   }
48196   {
48197     try {
48198       (arg1)->Swap(*arg2);
48199     } catch (std::out_of_range& e) {
48200       {
48201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48202       };
48203     } catch (std::exception& e) {
48204       {
48205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48206       };
48207     } catch (...) {
48208       {
48209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48210       };
48211     }
48212   }
48213 }
48214
48215
48216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48217   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48218
48219   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48220   {
48221     try {
48222       (arg1)->Clear();
48223     } catch (std::out_of_range& e) {
48224       {
48225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48226       };
48227     } catch (std::exception& e) {
48228       {
48229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (...) {
48232       {
48233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48234       };
48235     }
48236   }
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48241   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48242
48243   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48244   {
48245     try {
48246       (arg1)->Release();
48247     } catch (std::out_of_range& e) {
48248       {
48249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (std::exception& e) {
48252       {
48253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261 }
48262
48263
48264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48265   int jresult ;
48266   int result;
48267
48268   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48269   jresult = (int)result;
48270   return jresult;
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48275   void * jresult ;
48276   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48277
48278   {
48279     try {
48280       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48281     } catch (std::out_of_range& e) {
48282       {
48283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48284       };
48285     } catch (std::exception& e) {
48286       {
48287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48288       };
48289     } catch (...) {
48290       {
48291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48292       };
48293     }
48294   }
48295   jresult = (void *)result;
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48302
48303   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48304   {
48305     try {
48306       delete arg1;
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48318       };
48319     }
48320   }
48321 }
48322
48323
48324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48325   void * jresult ;
48326   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48327   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48328
48329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48330   if (!arg1) {
48331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48332     return 0;
48333   }
48334   {
48335     try {
48336       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48337     } catch (std::out_of_range& e) {
48338       {
48339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48340       };
48341     } catch (std::exception& e) {
48342       {
48343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48344       };
48345     } catch (...) {
48346       {
48347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48348       };
48349     }
48350   }
48351   jresult = (void *)result;
48352   return jresult;
48353 }
48354
48355
48356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48357   void * jresult ;
48358   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48359   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48360   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48361
48362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48363   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48364   if (!arg2) {
48365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48366     return 0;
48367   }
48368   {
48369     try {
48370       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48371     } catch (std::out_of_range& e) {
48372       {
48373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48374       };
48375     } catch (std::exception& e) {
48376       {
48377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48378       };
48379     } catch (...) {
48380       {
48381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48382       };
48383     }
48384   }
48385   jresult = (void *)result;
48386   return jresult;
48387 }
48388
48389
48390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48391   void * jresult ;
48392   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48393   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48394
48395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48396   {
48397     try {
48398       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48406       };
48407     } catch (...) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48410       };
48411     }
48412   }
48413   jresult = (void *)result;
48414   return jresult;
48415 }
48416
48417
48418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48419   void * jresult ;
48420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48421   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48422
48423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48424   {
48425     try {
48426       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48427     } catch (std::out_of_range& e) {
48428       {
48429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48430       };
48431     } catch (std::exception& e) {
48432       {
48433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48438       };
48439     }
48440   }
48441   jresult = (void *)result;
48442   return jresult;
48443 }
48444
48445
48446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48447   void * jresult ;
48448   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48449   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48450   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48451
48452   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48453   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48454   {
48455     try {
48456       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48457     } catch (std::out_of_range& e) {
48458       {
48459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48460       };
48461     } catch (std::exception& e) {
48462       {
48463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48464       };
48465     } catch (...) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48468       };
48469     }
48470   }
48471   jresult = (void *)result;
48472   return jresult;
48473 }
48474
48475
48476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48477   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48478   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48479
48480   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48481   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48482   if (!arg2) {
48483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48484     return ;
48485   }
48486   {
48487     try {
48488       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48489     } catch (std::out_of_range& e) {
48490       {
48491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48492       };
48493     } catch (std::exception& e) {
48494       {
48495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48496       };
48497     } catch (...) {
48498       {
48499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48500       };
48501     }
48502   }
48503 }
48504
48505
48506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48507   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48508   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48509   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48510
48511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48512   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48513   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48514   if (!arg3) {
48515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48516     return ;
48517   }
48518   {
48519     try {
48520       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535 }
48536
48537
48538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48540   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48541   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48542   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48543
48544   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48545   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48546   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48547   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48548   {
48549     try {
48550       (arg1)->Insert(arg2,arg3,arg4);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (...) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48562       };
48563     }
48564   }
48565 }
48566
48567
48568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48569   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48570   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48571
48572   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48573   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48574   {
48575     try {
48576       (arg1)->Reserve(arg2);
48577     } catch (std::out_of_range& e) {
48578       {
48579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48580       };
48581     } catch (std::exception& e) {
48582       {
48583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48584       };
48585     } catch (...) {
48586       {
48587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48588       };
48589     }
48590   }
48591 }
48592
48593
48594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48595   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48596   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48597
48598   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48599   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48600   {
48601     try {
48602       (arg1)->Resize(arg2);
48603     } catch (std::out_of_range& e) {
48604       {
48605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (std::exception& e) {
48608       {
48609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617 }
48618
48619
48620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48621   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48622   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48623   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48624
48625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48626   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48627   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48628   if (!arg3) {
48629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48630     return ;
48631   }
48632   {
48633     try {
48634       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48635     } catch (std::out_of_range& e) {
48636       {
48637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48638       };
48639     } catch (std::exception& e) {
48640       {
48641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (...) {
48644       {
48645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48646       };
48647     }
48648   }
48649 }
48650
48651
48652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48653   void * jresult ;
48654   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48655   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48656   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48657
48658   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48659   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48660   {
48661     try {
48662       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48663     } catch (std::out_of_range& e) {
48664       {
48665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48666       };
48667     } catch (std::exception& e) {
48668       {
48669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48670       };
48671     } catch (...) {
48672       {
48673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48674       };
48675     }
48676   }
48677   jresult = (void *)result;
48678   return jresult;
48679 }
48680
48681
48682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48683   void * jresult ;
48684   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48685   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48686   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48687   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48688
48689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48690   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48691   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48692   {
48693     try {
48694       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48695     } catch (std::out_of_range& e) {
48696       {
48697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48698       };
48699     } catch (std::exception& e) {
48700       {
48701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48702       };
48703     } catch (...) {
48704       {
48705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48706       };
48707     }
48708   }
48709   jresult = (void *)result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48715   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48716   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48717
48718   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48719   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48720   {
48721     try {
48722       (arg1)->Remove(arg2);
48723     } catch (std::out_of_range& e) {
48724       {
48725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (std::exception& e) {
48728       {
48729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (...) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48734       };
48735     }
48736   }
48737 }
48738
48739
48740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48741   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48742   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48743
48744   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48745   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48746   if (!arg2) {
48747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48748     return ;
48749   }
48750   {
48751     try {
48752       (arg1)->Swap(*arg2);
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48764       };
48765     }
48766   }
48767 }
48768
48769
48770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48771   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48772
48773   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48774   {
48775     try {
48776       (arg1)->Clear();
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (...) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48788       };
48789     }
48790   }
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48795   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48796
48797   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48798   {
48799     try {
48800       (arg1)->Release();
48801     } catch (std::out_of_range& e) {
48802       {
48803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48804       };
48805     } catch (std::exception& e) {
48806       {
48807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48808       };
48809     } catch (...) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48812       };
48813     }
48814   }
48815 }
48816
48817
48818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48819   void * jresult ;
48820   Dali::Signal< void () > *result = 0 ;
48821
48822   {
48823     try {
48824       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48825     } catch (std::out_of_range& e) {
48826       {
48827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (std::exception& e) {
48830       {
48831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48836       };
48837     }
48838   }
48839   jresult = (void *)result;
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48845   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48846
48847   arg1 = (Dali::Signal< void () > *)jarg1;
48848   {
48849     try {
48850       delete arg1;
48851     } catch (std::out_of_range& e) {
48852       {
48853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48854       };
48855     } catch (std::exception& e) {
48856       {
48857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48858       };
48859     } catch (...) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48862       };
48863     }
48864   }
48865 }
48866
48867
48868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48869   unsigned int jresult ;
48870   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48871   bool result;
48872
48873   arg1 = (Dali::Signal< void () > *)jarg1;
48874   {
48875     try {
48876       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48877     } catch (std::out_of_range& e) {
48878       {
48879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48880       };
48881     } catch (std::exception& e) {
48882       {
48883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48884       };
48885     } catch (...) {
48886       {
48887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48888       };
48889     }
48890   }
48891   jresult = result;
48892   return jresult;
48893 }
48894
48895
48896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48897   unsigned long jresult ;
48898   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48899   std::size_t result;
48900
48901   arg1 = (Dali::Signal< void () > *)jarg1;
48902   {
48903     try {
48904       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48905     } catch (std::out_of_range& e) {
48906       {
48907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48908       };
48909     } catch (std::exception& e) {
48910       {
48911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48912       };
48913     } catch (...) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48916       };
48917     }
48918   }
48919   jresult = (unsigned long)result;
48920   return jresult;
48921 }
48922
48923
48924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48925   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48926   void (*arg2)() = (void (*)()) 0 ;
48927
48928   arg1 = (Dali::Signal< void () > *)jarg1;
48929   arg2 = (void (*)())jarg2;
48930   {
48931     try {
48932       (arg1)->Connect(arg2);
48933     } catch (std::out_of_range& e) {
48934       {
48935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48936       };
48937     } catch (std::exception& e) {
48938       {
48939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48940       };
48941     } catch (...) {
48942       {
48943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48944       };
48945     }
48946   }
48947 }
48948
48949
48950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48951   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48952   void (*arg2)() = (void (*)()) 0 ;
48953
48954   arg1 = (Dali::Signal< void () > *)jarg1;
48955   arg2 = (void (*)())jarg2;
48956   {
48957     try {
48958       (arg1)->Disconnect(arg2);
48959     } catch (std::out_of_range& e) {
48960       {
48961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48962       };
48963     } catch (std::exception& e) {
48964       {
48965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48970       };
48971     }
48972   }
48973 }
48974
48975
48976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48977   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48978   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48979   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48980
48981   arg1 = (Dali::Signal< void () > *)jarg1;
48982   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48983   arg3 = (Dali::FunctorDelegate *)jarg3;
48984   {
48985     try {
48986       (arg1)->Connect(arg2,arg3);
48987     } catch (std::out_of_range& e) {
48988       {
48989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48990       };
48991     } catch (std::exception& e) {
48992       {
48993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48994       };
48995     } catch (...) {
48996       {
48997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48998       };
48999     }
49000   }
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
49005   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49006
49007   arg1 = (Dali::Signal< void () > *)jarg1;
49008   {
49009     try {
49010       (arg1)->Emit();
49011     } catch (std::out_of_range& e) {
49012       {
49013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49014       };
49015     } catch (std::exception& e) {
49016       {
49017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49022       };
49023     }
49024   }
49025 }
49026
49027
49028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
49029   unsigned int jresult ;
49030   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49031   bool result;
49032
49033   arg1 = (Dali::Signal< void (float) > *)jarg1;
49034   {
49035     try {
49036       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
49037     } catch (std::out_of_range& e) {
49038       {
49039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49040       };
49041     } catch (std::exception& e) {
49042       {
49043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49044       };
49045     } catch (...) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49048       };
49049     }
49050   }
49051   jresult = result;
49052   return jresult;
49053 }
49054
49055
49056 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
49057   unsigned long jresult ;
49058   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49059   std::size_t result;
49060
49061   arg1 = (Dali::Signal< void (float) > *)jarg1;
49062   {
49063     try {
49064       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (...) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49076       };
49077     }
49078   }
49079   jresult = (unsigned long)result;
49080   return jresult;
49081 }
49082
49083
49084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49086   void (*arg2)(float) = (void (*)(float)) 0 ;
49087
49088   arg1 = (Dali::Signal< void (float) > *)jarg1;
49089   arg2 = (void (*)(float))jarg2;
49090   {
49091     try {
49092       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49093     } catch (std::out_of_range& e) {
49094       {
49095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49096       };
49097     } catch (std::exception& e) {
49098       {
49099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49100       };
49101     } catch (...) {
49102       {
49103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49104       };
49105     }
49106   }
49107 }
49108
49109
49110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49111   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49112   void (*arg2)(float) = (void (*)(float)) 0 ;
49113
49114   arg1 = (Dali::Signal< void (float) > *)jarg1;
49115   arg2 = (void (*)(float))jarg2;
49116   {
49117     try {
49118       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49119     } catch (std::out_of_range& e) {
49120       {
49121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49122       };
49123     } catch (std::exception& e) {
49124       {
49125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49126       };
49127     } catch (...) {
49128       {
49129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49130       };
49131     }
49132   }
49133 }
49134
49135
49136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49137   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49138   float arg2 ;
49139
49140   arg1 = (Dali::Signal< void (float) > *)jarg1;
49141   arg2 = (float)jarg2;
49142   {
49143     try {
49144       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49145     } catch (std::out_of_range& e) {
49146       {
49147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49148       };
49149     } catch (std::exception& e) {
49150       {
49151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (...) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49156       };
49157     }
49158   }
49159 }
49160
49161
49162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49163   void * jresult ;
49164   Dali::Signal< void (float) > *result = 0 ;
49165
49166   {
49167     try {
49168       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49169     } catch (std::out_of_range& e) {
49170       {
49171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (std::exception& e) {
49174       {
49175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49180       };
49181     }
49182   }
49183   jresult = (void *)result;
49184   return jresult;
49185 }
49186
49187
49188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49189   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49190
49191   arg1 = (Dali::Signal< void (float) > *)jarg1;
49192   {
49193     try {
49194       delete arg1;
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49202       };
49203     } catch (...) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49206       };
49207     }
49208   }
49209 }
49210
49211
49212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49213   unsigned int jresult ;
49214   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49215   bool result;
49216
49217   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49218   {
49219     try {
49220       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49221     } catch (std::out_of_range& e) {
49222       {
49223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49224       };
49225     } catch (std::exception& e) {
49226       {
49227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49228       };
49229     } catch (...) {
49230       {
49231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49232       };
49233     }
49234   }
49235   jresult = result;
49236   return jresult;
49237 }
49238
49239
49240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49241   unsigned long jresult ;
49242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49243   std::size_t result;
49244
49245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49246   {
49247     try {
49248       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49249     } catch (std::out_of_range& e) {
49250       {
49251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49252       };
49253     } catch (std::exception& e) {
49254       {
49255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49260       };
49261     }
49262   }
49263   jresult = (unsigned long)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49271
49272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49274   {
49275     try {
49276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49284       };
49285     } catch (...) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49288       };
49289     }
49290   }
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49295   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49296   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49297
49298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49299   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49300   {
49301     try {
49302       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (...) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49314       };
49315     }
49316   }
49317 }
49318
49319
49320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49321   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49322   Dali::BaseHandle arg2 ;
49323   Dali::BaseHandle *argp2 ;
49324
49325   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49326   argp2 = (Dali::BaseHandle *)jarg2;
49327   if (!argp2) {
49328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49329     return ;
49330   }
49331   arg2 = *argp2;
49332   {
49333     try {
49334       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49335     } catch (std::out_of_range& e) {
49336       {
49337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49338       };
49339     } catch (std::exception& e) {
49340       {
49341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (...) {
49344       {
49345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49346       };
49347     }
49348   }
49349 }
49350
49351
49352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49353   void * jresult ;
49354   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49355
49356   {
49357     try {
49358       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49359     } catch (std::out_of_range& e) {
49360       {
49361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (std::exception& e) {
49364       {
49365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49366       };
49367     } catch (...) {
49368       {
49369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49370       };
49371     }
49372   }
49373   jresult = (void *)result;
49374   return jresult;
49375 }
49376
49377
49378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49379   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49380
49381   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49382   {
49383     try {
49384       delete arg1;
49385     } catch (std::out_of_range& e) {
49386       {
49387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49388       };
49389     } catch (std::exception& e) {
49390       {
49391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49396       };
49397     }
49398   }
49399 }
49400
49401
49402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49403   unsigned int jresult ;
49404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49405   bool result;
49406
49407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49408   {
49409     try {
49410       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425   jresult = result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49431   unsigned long jresult ;
49432   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49433   std::size_t result;
49434
49435   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49436   {
49437     try {
49438       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49439     } catch (std::out_of_range& e) {
49440       {
49441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49442       };
49443     } catch (std::exception& e) {
49444       {
49445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (...) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49450       };
49451     }
49452   }
49453   jresult = (unsigned long)result;
49454   return jresult;
49455 }
49456
49457
49458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49459   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49460   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49461
49462   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49463   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49464   {
49465     try {
49466       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49467     } catch (std::out_of_range& e) {
49468       {
49469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49470       };
49471     } catch (std::exception& e) {
49472       {
49473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49474       };
49475     } catch (...) {
49476       {
49477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49478       };
49479     }
49480   }
49481 }
49482
49483
49484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49485   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49486   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49487
49488   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49489   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49490   {
49491     try {
49492       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49500       };
49501     } catch (...) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49504       };
49505     }
49506   }
49507 }
49508
49509
49510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49511   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49512   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49513
49514   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49515   arg2 = (Dali::RefObject *)jarg2;
49516   {
49517     try {
49518       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49519     } catch (std::out_of_range& e) {
49520       {
49521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49522       };
49523     } catch (std::exception& e) {
49524       {
49525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49530       };
49531     }
49532   }
49533 }
49534
49535
49536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49537   void * jresult ;
49538   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49539
49540   {
49541     try {
49542       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49554       };
49555     }
49556   }
49557   jresult = (void *)result;
49558   return jresult;
49559 }
49560
49561
49562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49563   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49564
49565   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49566   {
49567     try {
49568       delete arg1;
49569     } catch (std::out_of_range& e) {
49570       {
49571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49572       };
49573     } catch (std::exception& e) {
49574       {
49575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49576       };
49577     } catch (...) {
49578       {
49579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49580       };
49581     }
49582   }
49583 }
49584
49585
49586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49587   unsigned int jresult ;
49588   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49589   bool result;
49590
49591   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49592   {
49593     try {
49594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49595     } catch (std::out_of_range& e) {
49596       {
49597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49598       };
49599     } catch (std::exception& e) {
49600       {
49601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49602       };
49603     } catch (...) {
49604       {
49605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49606       };
49607     }
49608   }
49609   jresult = result;
49610   return jresult;
49611 }
49612
49613
49614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49615   unsigned long jresult ;
49616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49617   std::size_t result;
49618
49619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49620   {
49621     try {
49622       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49623     } catch (std::out_of_range& e) {
49624       {
49625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (std::exception& e) {
49628       {
49629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637   jresult = (unsigned long)result;
49638   return jresult;
49639 }
49640
49641
49642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49643   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49644   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49645
49646   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49647   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49648   {
49649     try {
49650       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49651     } catch (std::out_of_range& e) {
49652       {
49653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49654       };
49655     } catch (std::exception& e) {
49656       {
49657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49658       };
49659     } catch (...) {
49660       {
49661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49662       };
49663     }
49664   }
49665 }
49666
49667
49668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49669   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49670   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49671
49672   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49673   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49674   {
49675     try {
49676       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691 }
49692
49693
49694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49695   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49696   Dali::PropertyNotification *arg2 = 0 ;
49697
49698   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49699   arg2 = (Dali::PropertyNotification *)jarg2;
49700   if (!arg2) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49702     return ;
49703   }
49704   {
49705     try {
49706       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49707     } catch (std::out_of_range& e) {
49708       {
49709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49710       };
49711     } catch (std::exception& e) {
49712       {
49713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (...) {
49716       {
49717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49718       };
49719     }
49720   }
49721 }
49722
49723
49724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49725   void * jresult ;
49726   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49727
49728   {
49729     try {
49730       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49731     } catch (std::out_of_range& e) {
49732       {
49733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (std::exception& e) {
49736       {
49737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (...) {
49740       {
49741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49742       };
49743     }
49744   }
49745   jresult = (void *)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49751   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49752
49753   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49754   {
49755     try {
49756       delete arg1;
49757     } catch (std::out_of_range& e) {
49758       {
49759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49760       };
49761     } catch (std::exception& e) {
49762       {
49763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (...) {
49766       {
49767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49768       };
49769     }
49770   }
49771 }
49772
49773
49774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49775   unsigned int jresult ;
49776   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49777   bool result;
49778
49779   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49780   {
49781     try {
49782       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (...) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49794       };
49795     }
49796   }
49797   jresult = result;
49798   return jresult;
49799 }
49800
49801
49802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49803   unsigned long jresult ;
49804   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49805   std::size_t result;
49806
49807   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49808   {
49809     try {
49810       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (...) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49822       };
49823     }
49824   }
49825   jresult = (unsigned long)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49831   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49832   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49833
49834   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49835   arg2 = (void (*)(Dali::Image))jarg2;
49836   {
49837     try {
49838       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49839     } catch (std::out_of_range& e) {
49840       {
49841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49842       };
49843     } catch (std::exception& e) {
49844       {
49845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (...) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49850       };
49851     }
49852   }
49853 }
49854
49855
49856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49857   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49858   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49859
49860   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49861   arg2 = (void (*)(Dali::Image))jarg2;
49862   {
49863     try {
49864       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49865     } catch (std::out_of_range& e) {
49866       {
49867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49868       };
49869     } catch (std::exception& e) {
49870       {
49871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (...) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49876       };
49877     }
49878   }
49879 }
49880
49881
49882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49883   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49884   Dali::Image arg2 ;
49885   Dali::Image *argp2 ;
49886
49887   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49888   argp2 = (Dali::Image *)jarg2;
49889   if (!argp2) {
49890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49891     return ;
49892   }
49893   arg2 = *argp2;
49894   {
49895     try {
49896       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49897     } catch (std::out_of_range& e) {
49898       {
49899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49900       };
49901     } catch (std::exception& e) {
49902       {
49903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49904       };
49905     } catch (...) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49908       };
49909     }
49910   }
49911 }
49912
49913
49914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49915   void * jresult ;
49916   Dali::Signal< void (Dali::Image) > *result = 0 ;
49917
49918   {
49919     try {
49920       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49921     } catch (std::out_of_range& e) {
49922       {
49923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49924       };
49925     } catch (std::exception& e) {
49926       {
49927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49932       };
49933     }
49934   }
49935   jresult = (void *)result;
49936   return jresult;
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49941   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49942
49943   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49944   {
49945     try {
49946       delete arg1;
49947     } catch (std::out_of_range& e) {
49948       {
49949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49950       };
49951     } catch (std::exception& e) {
49952       {
49953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49954       };
49955     } catch (...) {
49956       {
49957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49958       };
49959     }
49960   }
49961 }
49962
49963
49964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49965   void * jresult ;
49966   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49967
49968   {
49969     try {
49970       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49971     } catch (std::out_of_range& e) {
49972       {
49973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (std::exception& e) {
49976       {
49977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49982       };
49983     }
49984   }
49985   jresult = (void *)result;
49986   return jresult;
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49991   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49992
49993   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49994   {
49995     try {
49996       delete arg1;
49997     } catch (std::out_of_range& e) {
49998       {
49999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (std::exception& e) {
50002       {
50003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011 }
50012
50013
50014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
50015   unsigned int jresult ;
50016   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50017   bool result;
50018
50019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50020   {
50021     try {
50022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
50023     } catch (std::out_of_range& e) {
50024       {
50025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50026       };
50027     } catch (std::exception& e) {
50028       {
50029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (...) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50034       };
50035     }
50036   }
50037   jresult = result;
50038   return jresult;
50039 }
50040
50041
50042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50043   unsigned long jresult ;
50044   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50045   std::size_t result;
50046
50047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50048   {
50049     try {
50050       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50058       };
50059     } catch (...) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50062       };
50063     }
50064   }
50065   jresult = (unsigned long)result;
50066   return jresult;
50067 }
50068
50069
50070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50071   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50072   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50073
50074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50075   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50076   {
50077     try {
50078       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (...) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50090       };
50091     }
50092   }
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50097   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50098   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50099
50100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50101   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50102   {
50103     try {
50104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50105     } catch (std::out_of_range& e) {
50106       {
50107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50108       };
50109     } catch (std::exception& e) {
50110       {
50111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50116       };
50117     }
50118   }
50119 }
50120
50121
50122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50123   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50124   Dali::Actor arg2 ;
50125   Dali::LongPressGesture *arg3 = 0 ;
50126   Dali::Actor *argp2 ;
50127
50128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50129   argp2 = (Dali::Actor *)jarg2;
50130   if (!argp2) {
50131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50132     return ;
50133   }
50134   arg2 = *argp2;
50135   arg3 = (Dali::LongPressGesture *)jarg3;
50136   if (!arg3) {
50137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50138     return ;
50139   }
50140   {
50141     try {
50142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50143     } catch (std::out_of_range& e) {
50144       {
50145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50146       };
50147     } catch (std::exception& e) {
50148       {
50149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50150       };
50151     } catch (...) {
50152       {
50153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50154       };
50155     }
50156   }
50157 }
50158
50159
50160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50161   void * jresult ;
50162   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50163
50164   {
50165     try {
50166       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (...) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50178       };
50179     }
50180   }
50181   jresult = (void *)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50187   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50188
50189   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50190   {
50191     try {
50192       delete arg1;
50193     } catch (std::out_of_range& e) {
50194       {
50195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50196       };
50197     } catch (std::exception& e) {
50198       {
50199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50200       };
50201     } catch (...) {
50202       {
50203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50204       };
50205     }
50206   }
50207 }
50208
50209
50210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50211   unsigned int jresult ;
50212   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50213   bool result;
50214
50215   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50216   {
50217     try {
50218       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
50219     } catch (std::out_of_range& e) {
50220       {
50221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50222       };
50223     } catch (std::exception& e) {
50224       {
50225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50226       };
50227     } catch (...) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50230       };
50231     }
50232   }
50233   jresult = result;
50234   return jresult;
50235 }
50236
50237
50238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50239   unsigned long jresult ;
50240   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50241   std::size_t result;
50242
50243   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50244   {
50245     try {
50246       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (...) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50258       };
50259     }
50260   }
50261   jresult = (unsigned long)result;
50262   return jresult;
50263 }
50264
50265
50266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50267   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50268   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50269
50270   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50271   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50272   {
50273     try {
50274       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50275     } catch (std::out_of_range& e) {
50276       {
50277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50278       };
50279     } catch (std::exception& e) {
50280       {
50281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50282       };
50283     } catch (...) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50286       };
50287     }
50288   }
50289 }
50290
50291
50292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50293   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50294   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50295
50296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50297   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50298   {
50299     try {
50300       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50301     } catch (std::out_of_range& e) {
50302       {
50303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50304       };
50305     } catch (std::exception& e) {
50306       {
50307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50312       };
50313     }
50314   }
50315 }
50316
50317
50318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50319   unsigned int jresult ;
50320   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50321   Dali::Actor arg2 ;
50322   Dali::TouchData *arg3 = 0 ;
50323   Dali::Actor *argp2 ;
50324   bool result;
50325
50326   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50327   argp2 = (Dali::Actor *)jarg2;
50328   if (!argp2) {
50329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50330     return 0;
50331   }
50332   arg2 = *argp2;
50333   arg3 = (Dali::TouchData *)jarg3;
50334   if (!arg3) {
50335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50336     return 0;
50337   }
50338   {
50339     try {
50340       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50341     } catch (std::out_of_range& e) {
50342       {
50343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (std::exception& e) {
50346       {
50347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355   jresult = result;
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50361   void * jresult ;
50362   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50363
50364   {
50365     try {
50366       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381   jresult = (void *)result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50387   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50388
50389   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50390   {
50391     try {
50392       delete arg1;
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50400       };
50401     } catch (...) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50404       };
50405     }
50406   }
50407 }
50408
50409
50410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50411   unsigned int jresult ;
50412   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50413   bool result;
50414
50415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50416   {
50417     try {
50418       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
50419     } catch (std::out_of_range& e) {
50420       {
50421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50422       };
50423     } catch (std::exception& e) {
50424       {
50425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50426       };
50427     } catch (...) {
50428       {
50429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50430       };
50431     }
50432   }
50433   jresult = result;
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50439   unsigned long jresult ;
50440   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50441   std::size_t result;
50442
50443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50444   {
50445     try {
50446       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (...) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50458       };
50459     }
50460   }
50461   jresult = (unsigned long)result;
50462   return jresult;
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50467   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50468   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50469
50470   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50471   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50472   {
50473     try {
50474       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50475     } catch (std::out_of_range& e) {
50476       {
50477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50478       };
50479     } catch (std::exception& e) {
50480       {
50481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (...) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50486       };
50487     }
50488   }
50489 }
50490
50491
50492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50493   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50494   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50495
50496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50497   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50498   {
50499     try {
50500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50501     } catch (std::out_of_range& e) {
50502       {
50503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50504       };
50505     } catch (std::exception& e) {
50506       {
50507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50508       };
50509     } catch (...) {
50510       {
50511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50512       };
50513     }
50514   }
50515 }
50516
50517
50518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50519   unsigned int jresult ;
50520   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50521   Dali::Actor arg2 ;
50522   Dali::HoverEvent *arg3 = 0 ;
50523   Dali::Actor *argp2 ;
50524   bool result;
50525
50526   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50527   argp2 = (Dali::Actor *)jarg2;
50528   if (!argp2) {
50529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50530     return 0;
50531   }
50532   arg2 = *argp2;
50533   arg3 = (Dali::HoverEvent *)jarg3;
50534   if (!arg3) {
50535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50536     return 0;
50537   }
50538   {
50539     try {
50540       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50541     } catch (std::out_of_range& e) {
50542       {
50543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (std::exception& e) {
50546       {
50547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50561   void * jresult ;
50562   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50563
50564   {
50565     try {
50566       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50567     } catch (std::out_of_range& e) {
50568       {
50569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (std::exception& e) {
50572       {
50573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (...) {
50576       {
50577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50578       };
50579     }
50580   }
50581   jresult = (void *)result;
50582   return jresult;
50583 }
50584
50585
50586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50587   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50588
50589   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50590   {
50591     try {
50592       delete arg1;
50593     } catch (std::out_of_range& e) {
50594       {
50595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50596       };
50597     } catch (std::exception& e) {
50598       {
50599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50600       };
50601     } catch (...) {
50602       {
50603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50604       };
50605     }
50606   }
50607 }
50608
50609
50610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50611   unsigned int jresult ;
50612   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50613   bool result;
50614
50615   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50616   {
50617     try {
50618       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50630       };
50631     }
50632   }
50633   jresult = result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50639   unsigned long jresult ;
50640   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50641   std::size_t result;
50642
50643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50644   {
50645     try {
50646       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
50647     } catch (std::out_of_range& e) {
50648       {
50649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50650       };
50651     } catch (std::exception& e) {
50652       {
50653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50654       };
50655     } catch (...) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50658       };
50659     }
50660   }
50661   jresult = (unsigned long)result;
50662   return jresult;
50663 }
50664
50665
50666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50667   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50668   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50669
50670   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50671   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50672   {
50673     try {
50674       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50675     } catch (std::out_of_range& e) {
50676       {
50677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50678       };
50679     } catch (std::exception& e) {
50680       {
50681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (...) {
50684       {
50685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50686       };
50687     }
50688   }
50689 }
50690
50691
50692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50693   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50694   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50695
50696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50697   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50698   {
50699     try {
50700       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50701     } catch (std::out_of_range& e) {
50702       {
50703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (std::exception& e) {
50706       {
50707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50708       };
50709     } catch (...) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50712       };
50713     }
50714   }
50715 }
50716
50717
50718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50719   unsigned int jresult ;
50720   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50721   Dali::Actor arg2 ;
50722   Dali::WheelEvent *arg3 = 0 ;
50723   Dali::Actor *argp2 ;
50724   bool result;
50725
50726   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50727   argp2 = (Dali::Actor *)jarg2;
50728   if (!argp2) {
50729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50730     return 0;
50731   }
50732   arg2 = *argp2;
50733   arg3 = (Dali::WheelEvent *)jarg3;
50734   if (!arg3) {
50735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50736     return 0;
50737   }
50738   {
50739     try {
50740       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50741     } catch (std::out_of_range& e) {
50742       {
50743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50744       };
50745     } catch (std::exception& e) {
50746       {
50747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50748       };
50749     } catch (...) {
50750       {
50751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50752       };
50753     }
50754   }
50755   jresult = result;
50756   return jresult;
50757 }
50758
50759
50760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50761   void * jresult ;
50762   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50763
50764   {
50765     try {
50766       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (...) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50778       };
50779     }
50780   }
50781   jresult = (void *)result;
50782   return jresult;
50783 }
50784
50785
50786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50787   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50788
50789   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50790   {
50791     try {
50792       delete arg1;
50793     } catch (std::out_of_range& e) {
50794       {
50795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (std::exception& e) {
50798       {
50799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50800       };
50801     } catch (...) {
50802       {
50803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50804       };
50805     }
50806   }
50807 }
50808
50809
50810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50811   unsigned int jresult ;
50812   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50813   bool result;
50814
50815   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50816   {
50817     try {
50818       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50819     } catch (std::out_of_range& e) {
50820       {
50821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (std::exception& e) {
50824       {
50825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50826       };
50827     } catch (...) {
50828       {
50829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50830       };
50831     }
50832   }
50833   jresult = result;
50834   return jresult;
50835 }
50836
50837
50838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50839   unsigned long jresult ;
50840   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50841   std::size_t result;
50842
50843   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50844   {
50845     try {
50846       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50847     } catch (std::out_of_range& e) {
50848       {
50849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (std::exception& e) {
50852       {
50853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861   jresult = (unsigned long)result;
50862   return jresult;
50863 }
50864
50865
50866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50867   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50868   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50869
50870   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50871   arg2 = (void (*)(Dali::Actor))jarg2;
50872   {
50873     try {
50874       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50875     } catch (std::out_of_range& e) {
50876       {
50877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50878       };
50879     } catch (std::exception& e) {
50880       {
50881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50882       };
50883     } catch (...) {
50884       {
50885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50886       };
50887     }
50888   }
50889 }
50890
50891
50892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50894   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50897   arg2 = (void (*)(Dali::Actor))jarg2;
50898   {
50899     try {
50900       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50908       };
50909     } catch (...) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50912       };
50913     }
50914   }
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50919   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50920   Dali::Actor arg2 ;
50921   Dali::Actor *argp2 ;
50922
50923   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50924   argp2 = (Dali::Actor *)jarg2;
50925   if (!argp2) {
50926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50927     return ;
50928   }
50929   arg2 = *argp2;
50930   {
50931     try {
50932       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50933     } catch (std::out_of_range& e) {
50934       {
50935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50936       };
50937     } catch (std::exception& e) {
50938       {
50939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50940       };
50941     } catch (...) {
50942       {
50943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50944       };
50945     }
50946   }
50947 }
50948
50949
50950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50951   void * jresult ;
50952   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50953
50954   {
50955     try {
50956       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (...) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50968       };
50969     }
50970   }
50971   jresult = (void *)result;
50972   return jresult;
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50977   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50978
50979   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50980   {
50981     try {
50982       delete arg1;
50983     } catch (std::out_of_range& e) {
50984       {
50985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50986       };
50987     } catch (std::exception& e) {
50988       {
50989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50990       };
50991     } catch (...) {
50992       {
50993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50994       };
50995     }
50996   }
50997 }
50998
50999
51000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
51001   unsigned int jresult ;
51002   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51003   bool result;
51004
51005   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51006   {
51007     try {
51008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51009     } catch (std::out_of_range& e) {
51010       {
51011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (std::exception& e) {
51014       {
51015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (...) {
51018       {
51019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51020       };
51021     }
51022   }
51023   jresult = result;
51024   return jresult;
51025 }
51026
51027
51028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
51029   unsigned long jresult ;
51030   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51031   std::size_t result;
51032
51033   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51034   {
51035     try {
51036       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51044       };
51045     } catch (...) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51048       };
51049     }
51050   }
51051   jresult = (unsigned long)result;
51052   return jresult;
51053 }
51054
51055
51056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
51057   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51058   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51059
51060   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51061   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51062   {
51063     try {
51064       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51076       };
51077     }
51078   }
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51083   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51084   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51085
51086   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51087   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51088   {
51089     try {
51090       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51091     } catch (std::out_of_range& e) {
51092       {
51093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51094       };
51095     } catch (std::exception& e) {
51096       {
51097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (...) {
51100       {
51101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51102       };
51103     }
51104   }
51105 }
51106
51107
51108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51109   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51110   Dali::KeyEvent *arg2 = 0 ;
51111
51112   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51113   arg2 = (Dali::KeyEvent *)jarg2;
51114   if (!arg2) {
51115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51116     return ;
51117   }
51118   {
51119     try {
51120       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51128       };
51129     } catch (...) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51132       };
51133     }
51134   }
51135 }
51136
51137
51138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51139   void * jresult ;
51140   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51141
51142   {
51143     try {
51144       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51145     } catch (std::out_of_range& e) {
51146       {
51147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (std::exception& e) {
51150       {
51151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51156       };
51157     }
51158   }
51159   jresult = (void *)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51165   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51166
51167   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51168   {
51169     try {
51170       delete arg1;
51171     } catch (std::out_of_range& e) {
51172       {
51173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51174       };
51175     } catch (std::exception& e) {
51176       {
51177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51182       };
51183     }
51184   }
51185 }
51186
51187
51188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51189   unsigned int jresult ;
51190   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51191   bool result;
51192
51193   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51194   {
51195     try {
51196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51197     } catch (std::out_of_range& e) {
51198       {
51199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (std::exception& e) {
51202       {
51203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211   jresult = result;
51212   return jresult;
51213 }
51214
51215
51216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51217   unsigned long jresult ;
51218   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51219   std::size_t result;
51220
51221   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51222   {
51223     try {
51224       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51236       };
51237     }
51238   }
51239   jresult = (unsigned long)result;
51240   return jresult;
51241 }
51242
51243
51244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51245   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51246   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51247
51248   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51249   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51250   {
51251     try {
51252       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51253     } catch (std::out_of_range& e) {
51254       {
51255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51256       };
51257     } catch (std::exception& e) {
51258       {
51259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51260       };
51261     } catch (...) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51264       };
51265     }
51266   }
51267 }
51268
51269
51270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51271   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51272   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51273
51274   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51275   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51276   {
51277     try {
51278       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293 }
51294
51295
51296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51297   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51298   Dali::TouchData *arg2 = 0 ;
51299
51300   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51301   arg2 = (Dali::TouchData *)jarg2;
51302   if (!arg2) {
51303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51304     return ;
51305   }
51306   {
51307     try {
51308       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51309     } catch (std::out_of_range& e) {
51310       {
51311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (std::exception& e) {
51314       {
51315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51320       };
51321     }
51322   }
51323 }
51324
51325
51326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51327   void * jresult ;
51328   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51329
51330   {
51331     try {
51332       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (...) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51344       };
51345     }
51346   }
51347   jresult = (void *)result;
51348   return jresult;
51349 }
51350
51351
51352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51353   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51354
51355   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51356   {
51357     try {
51358       delete arg1;
51359     } catch (std::out_of_range& e) {
51360       {
51361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51362       };
51363     } catch (std::exception& e) {
51364       {
51365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51366       };
51367     } catch (...) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51370       };
51371     }
51372   }
51373 }
51374
51375
51376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51377   unsigned int jresult ;
51378   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51379   bool result;
51380
51381   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51382   {
51383     try {
51384       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51385     } catch (std::out_of_range& e) {
51386       {
51387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51388       };
51389     } catch (std::exception& e) {
51390       {
51391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51392       };
51393     } catch (...) {
51394       {
51395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51396       };
51397     }
51398   }
51399   jresult = result;
51400   return jresult;
51401 }
51402
51403
51404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51405   unsigned long jresult ;
51406   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51407   std::size_t result;
51408
51409   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51410   {
51411     try {
51412       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51413     } catch (std::out_of_range& e) {
51414       {
51415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51416       };
51417     } catch (std::exception& e) {
51418       {
51419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51424       };
51425     }
51426   }
51427   jresult = (unsigned long)result;
51428   return jresult;
51429 }
51430
51431
51432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51433   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51434   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51435
51436   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51437   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51438   {
51439     try {
51440       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51452       };
51453     }
51454   }
51455 }
51456
51457
51458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51459   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51460   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51461
51462   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51463   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51464   {
51465     try {
51466       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51467     } catch (std::out_of_range& e) {
51468       {
51469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (std::exception& e) {
51472       {
51473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481 }
51482
51483
51484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51485   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51486   Dali::WheelEvent *arg2 = 0 ;
51487
51488   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51489   arg2 = (Dali::WheelEvent *)jarg2;
51490   if (!arg2) {
51491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51492     return ;
51493   }
51494   {
51495     try {
51496       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51497     } catch (std::out_of_range& e) {
51498       {
51499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (std::exception& e) {
51502       {
51503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511 }
51512
51513
51514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51515   void * jresult ;
51516   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51517
51518   {
51519     try {
51520       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51532       };
51533     }
51534   }
51535   jresult = (void *)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51541   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51542
51543   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51544   {
51545     try {
51546       delete arg1;
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51558       };
51559     }
51560   }
51561 }
51562
51563
51564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51565   void * jresult ;
51566   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51567
51568   {
51569     try {
51570       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51571     } catch (std::out_of_range& e) {
51572       {
51573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (std::exception& e) {
51576       {
51577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51578       };
51579     } catch (...) {
51580       {
51581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51582       };
51583     }
51584   }
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51591   void * jresult ;
51592   Dali::Radian arg1 ;
51593   Dali::Radian arg2 ;
51594   Dali::Radian *argp1 ;
51595   Dali::Radian *argp2 ;
51596   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51597
51598   argp1 = (Dali::Radian *)jarg1;
51599   if (!argp1) {
51600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51601     return 0;
51602   }
51603   arg1 = *argp1;
51604   argp2 = (Dali::Radian *)jarg2;
51605   if (!argp2) {
51606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51607     return 0;
51608   }
51609   arg2 = *argp2;
51610   {
51611     try {
51612       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (...) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51624       };
51625     }
51626   }
51627   jresult = (void *)result;
51628   return jresult;
51629 }
51630
51631
51632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51633   void * jresult ;
51634   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51635   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51636
51637   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51638   if (!arg1) {
51639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51640     return 0;
51641   }
51642   {
51643     try {
51644       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51645     } catch (std::out_of_range& e) {
51646       {
51647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (std::exception& e) {
51650       {
51651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659   jresult = (void *)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51665   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51666   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51667
51668   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51669   arg2 = (Dali::Radian *)jarg2;
51670   if (arg1) (arg1)->first = *arg2;
51671 }
51672
51673
51674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51675   void * jresult ;
51676   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51677   Dali::Radian *result = 0 ;
51678
51679   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51680   result = (Dali::Radian *)& ((arg1)->first);
51681   jresult = (void *)result;
51682   return jresult;
51683 }
51684
51685
51686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51687   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51688   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51689
51690   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51691   arg2 = (Dali::Radian *)jarg2;
51692   if (arg1) (arg1)->second = *arg2;
51693 }
51694
51695
51696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51697   void * jresult ;
51698   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51699   Dali::Radian *result = 0 ;
51700
51701   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51702   result = (Dali::Radian *)& ((arg1)->second);
51703   jresult = (void *)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51709   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51710
51711   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51712   {
51713     try {
51714       delete arg1;
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51722       };
51723     } catch (...) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51726       };
51727     }
51728   }
51729 }
51730
51731
51732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51733   unsigned int jresult ;
51734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51735   bool result;
51736
51737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51738   {
51739     try {
51740       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
51741     } catch (std::out_of_range& e) {
51742       {
51743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51744       };
51745     } catch (std::exception& e) {
51746       {
51747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (...) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51752       };
51753     }
51754   }
51755   jresult = result;
51756   return jresult;
51757 }
51758
51759
51760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51761   unsigned long jresult ;
51762   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51763   std::size_t result;
51764
51765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51766   {
51767     try {
51768       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
51769     } catch (std::out_of_range& e) {
51770       {
51771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51772       };
51773     } catch (std::exception& e) {
51774       {
51775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51776       };
51777     } catch (...) {
51778       {
51779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51780       };
51781     }
51782   }
51783   jresult = (unsigned long)result;
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51789   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51790   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51791
51792   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51793   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51794   {
51795     try {
51796       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51797     } catch (std::out_of_range& e) {
51798       {
51799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51800       };
51801     } catch (std::exception& e) {
51802       {
51803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (...) {
51806       {
51807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51808       };
51809     }
51810   }
51811 }
51812
51813
51814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51815   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51816   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51817
51818   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51819   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51820   {
51821     try {
51822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51823     } catch (std::out_of_range& e) {
51824       {
51825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51826       };
51827     } catch (std::exception& e) {
51828       {
51829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51834       };
51835     }
51836   }
51837 }
51838
51839
51840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51841   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51842   Dali::Actor arg2 ;
51843   Dali::PanGesture *arg3 = 0 ;
51844   Dali::Actor *argp2 ;
51845
51846   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51847   argp2 = (Dali::Actor *)jarg2;
51848   if (!argp2) {
51849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51850     return ;
51851   }
51852   arg2 = *argp2;
51853   arg3 = (Dali::PanGesture *)jarg3;
51854   if (!arg3) {
51855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51856     return ;
51857   }
51858   {
51859     try {
51860       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51861     } catch (std::out_of_range& e) {
51862       {
51863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51864       };
51865     } catch (std::exception& e) {
51866       {
51867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51868       };
51869     } catch (...) {
51870       {
51871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51872       };
51873     }
51874   }
51875 }
51876
51877
51878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51879   void * jresult ;
51880   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51881
51882   {
51883     try {
51884       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (void *)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51905   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51906
51907   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51908   {
51909     try {
51910       delete arg1;
51911     } catch (std::out_of_range& e) {
51912       {
51913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51914       };
51915     } catch (std::exception& e) {
51916       {
51917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (...) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51922       };
51923     }
51924   }
51925 }
51926
51927
51928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51929   unsigned int jresult ;
51930   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51931   bool result;
51932
51933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51934   {
51935     try {
51936       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
51937     } catch (std::out_of_range& e) {
51938       {
51939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51940       };
51941     } catch (std::exception& e) {
51942       {
51943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (...) {
51946       {
51947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51948       };
51949     }
51950   }
51951   jresult = result;
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51957   unsigned long jresult ;
51958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51959   std::size_t result;
51960
51961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51962   {
51963     try {
51964       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51972       };
51973     } catch (...) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51976       };
51977     }
51978   }
51979   jresult = (unsigned long)result;
51980   return jresult;
51981 }
51982
51983
51984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51985   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51986   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51987
51988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51989   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51990   {
51991     try {
51992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007 }
52008
52009
52010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52011   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52012   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
52013
52014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52015   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
52016   {
52017     try {
52018       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52030       };
52031     }
52032   }
52033 }
52034
52035
52036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52037   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52038   Dali::Actor arg2 ;
52039   Dali::PinchGesture *arg3 = 0 ;
52040   Dali::Actor *argp2 ;
52041
52042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52043   argp2 = (Dali::Actor *)jarg2;
52044   if (!argp2) {
52045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52046     return ;
52047   }
52048   arg2 = *argp2;
52049   arg3 = (Dali::PinchGesture *)jarg3;
52050   if (!arg3) {
52051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
52052     return ;
52053   }
52054   {
52055     try {
52056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
52057     } catch (std::out_of_range& e) {
52058       {
52059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (std::exception& e) {
52062       {
52063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (...) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52068       };
52069     }
52070   }
52071 }
52072
52073
52074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
52075   void * jresult ;
52076   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
52077
52078   {
52079     try {
52080       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095   jresult = (void *)result;
52096   return jresult;
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52101   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52102
52103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52104   {
52105     try {
52106       delete arg1;
52107     } catch (std::out_of_range& e) {
52108       {
52109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52110       };
52111     } catch (std::exception& e) {
52112       {
52113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52114       };
52115     } catch (...) {
52116       {
52117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52118       };
52119     }
52120   }
52121 }
52122
52123
52124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52125   unsigned int jresult ;
52126   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52127   bool result;
52128
52129   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52130   {
52131     try {
52132       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
52133     } catch (std::out_of_range& e) {
52134       {
52135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52136       };
52137     } catch (std::exception& e) {
52138       {
52139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52140       };
52141     } catch (...) {
52142       {
52143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52144       };
52145     }
52146   }
52147   jresult = result;
52148   return jresult;
52149 }
52150
52151
52152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52153   unsigned long jresult ;
52154   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52155   std::size_t result;
52156
52157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52158   {
52159     try {
52160       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
52161     } catch (std::out_of_range& e) {
52162       {
52163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52164       };
52165     } catch (std::exception& e) {
52166       {
52167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52168       };
52169     } catch (...) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52172       };
52173     }
52174   }
52175   jresult = (unsigned long)result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52181   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52182   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52183
52184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52185   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52186   {
52187     try {
52188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52200       };
52201     }
52202   }
52203 }
52204
52205
52206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52207   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52208   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52209
52210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52211   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52212   {
52213     try {
52214       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (...) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52226       };
52227     }
52228   }
52229 }
52230
52231
52232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52233   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52234   Dali::Actor arg2 ;
52235   Dali::TapGesture *arg3 = 0 ;
52236   Dali::Actor *argp2 ;
52237
52238   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52239   argp2 = (Dali::Actor *)jarg2;
52240   if (!argp2) {
52241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52242     return ;
52243   }
52244   arg2 = *argp2;
52245   arg3 = (Dali::TapGesture *)jarg3;
52246   if (!arg3) {
52247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52248     return ;
52249   }
52250   {
52251     try {
52252       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52264       };
52265     }
52266   }
52267 }
52268
52269
52270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52271   void * jresult ;
52272   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52273
52274   {
52275     try {
52276       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52277     } catch (std::out_of_range& e) {
52278       {
52279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52280       };
52281     } catch (std::exception& e) {
52282       {
52283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52284       };
52285     } catch (...) {
52286       {
52287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52288       };
52289     }
52290   }
52291   jresult = (void *)result;
52292   return jresult;
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52297   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52298
52299   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52300   {
52301     try {
52302       delete arg1;
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52310       };
52311     } catch (...) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52314       };
52315     }
52316   }
52317 }
52318
52319
52320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52321   unsigned int jresult ;
52322   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52323   bool result;
52324
52325   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52326   {
52327     try {
52328       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343   jresult = result;
52344   return jresult;
52345 }
52346
52347
52348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52349   unsigned long jresult ;
52350   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52351   std::size_t result;
52352
52353   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52354   {
52355     try {
52356       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52368       };
52369     }
52370   }
52371   jresult = (unsigned long)result;
52372   return jresult;
52373 }
52374
52375
52376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52377   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52378   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52379
52380   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52381   arg2 = (void (*)(Dali::Animation &))jarg2;
52382   {
52383     try {
52384       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52392       };
52393     } catch (...) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52396       };
52397     }
52398   }
52399 }
52400
52401
52402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52403   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52404   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52405
52406   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52407   arg2 = (void (*)(Dali::Animation &))jarg2;
52408   {
52409     try {
52410       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52418       };
52419     } catch (...) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52422       };
52423     }
52424   }
52425 }
52426
52427
52428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52429   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52430   Dali::Animation *arg2 = 0 ;
52431
52432   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52433   arg2 = (Dali::Animation *)jarg2;
52434   if (!arg2) {
52435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52436     return ;
52437   }
52438   {
52439     try {
52440       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52441     } catch (std::out_of_range& e) {
52442       {
52443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52444       };
52445     } catch (std::exception& e) {
52446       {
52447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (...) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52452       };
52453     }
52454   }
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52459   void * jresult ;
52460   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52461
52462   {
52463     try {
52464       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52465     } catch (std::out_of_range& e) {
52466       {
52467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (std::exception& e) {
52470       {
52471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52472       };
52473     } catch (...) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52476       };
52477     }
52478   }
52479   jresult = (void *)result;
52480   return jresult;
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52485   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52486
52487   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52488   {
52489     try {
52490       delete arg1;
52491     } catch (std::out_of_range& e) {
52492       {
52493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52494       };
52495     } catch (std::exception& e) {
52496       {
52497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52498       };
52499     } catch (...) {
52500       {
52501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52502       };
52503     }
52504   }
52505 }
52506
52507
52508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52509   unsigned int jresult ;
52510   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52511   bool result;
52512
52513   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52514   {
52515     try {
52516       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52524       };
52525     } catch (...) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52528       };
52529     }
52530   }
52531   jresult = result;
52532   return jresult;
52533 }
52534
52535
52536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52537   unsigned long jresult ;
52538   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52539   std::size_t result;
52540
52541   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52542   {
52543     try {
52544       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52545     } catch (std::out_of_range& e) {
52546       {
52547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52548       };
52549     } catch (std::exception& e) {
52550       {
52551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (...) {
52554       {
52555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52556       };
52557     }
52558   }
52559   jresult = (unsigned long)result;
52560   return jresult;
52561 }
52562
52563
52564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52565   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52566   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52567
52568   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52569   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52570   {
52571     try {
52572       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52573     } catch (std::out_of_range& e) {
52574       {
52575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52576       };
52577     } catch (std::exception& e) {
52578       {
52579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52584       };
52585     }
52586   }
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52591   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52592   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52593
52594   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52595   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52596   {
52597     try {
52598       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52599     } catch (std::out_of_range& e) {
52600       {
52601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52602       };
52603     } catch (std::exception& e) {
52604       {
52605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52610       };
52611     }
52612   }
52613 }
52614
52615
52616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52617   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52618   Dali::ResourceImage arg2 ;
52619   Dali::ResourceImage *argp2 ;
52620
52621   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52622   argp2 = (Dali::ResourceImage *)jarg2;
52623   if (!argp2) {
52624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52625     return ;
52626   }
52627   arg2 = *argp2;
52628   {
52629     try {
52630       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52631     } catch (std::out_of_range& e) {
52632       {
52633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52634       };
52635     } catch (std::exception& e) {
52636       {
52637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (...) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52642       };
52643     }
52644   }
52645 }
52646
52647
52648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52649   void * jresult ;
52650   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52651
52652   {
52653     try {
52654       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52655     } catch (std::out_of_range& e) {
52656       {
52657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (std::exception& e) {
52660       {
52661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (...) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52666       };
52667     }
52668   }
52669   jresult = (void *)result;
52670   return jresult;
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52675   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52676
52677   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52678   {
52679     try {
52680       delete arg1;
52681     } catch (std::out_of_range& e) {
52682       {
52683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52684       };
52685     } catch (std::exception& e) {
52686       {
52687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52688       };
52689     } catch (...) {
52690       {
52691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52692       };
52693     }
52694   }
52695 }
52696
52697
52698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52699   unsigned int jresult ;
52700   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52701   bool result;
52702
52703   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52704   {
52705     try {
52706       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52707     } catch (std::out_of_range& e) {
52708       {
52709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52710       };
52711     } catch (std::exception& e) {
52712       {
52713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (...) {
52716       {
52717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52718       };
52719     }
52720   }
52721   jresult = result;
52722   return jresult;
52723 }
52724
52725
52726 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52727   unsigned long jresult ;
52728   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52729   std::size_t result;
52730
52731   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52732   {
52733     try {
52734       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
52735     } catch (std::out_of_range& e) {
52736       {
52737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52738       };
52739     } catch (std::exception& e) {
52740       {
52741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (...) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52746       };
52747     }
52748   }
52749   jresult = (unsigned long)result;
52750   return jresult;
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52755   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52756   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52757
52758   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52759   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52760   {
52761     try {
52762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (...) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52774       };
52775     }
52776   }
52777 }
52778
52779
52780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52781   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52782   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52783
52784   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52785   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52786   {
52787     try {
52788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52796       };
52797     } catch (...) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52800       };
52801     }
52802   }
52803 }
52804
52805
52806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52807   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52808   Dali::Actor arg2 ;
52809   bool arg3 ;
52810   Dali::DevelActor::VisibilityChange::Type arg4 ;
52811   Dali::Actor *argp2 ;
52812
52813   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52814   argp2 = (Dali::Actor *)jarg2;
52815   if (!argp2) {
52816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52817     return ;
52818   }
52819   arg2 = *argp2;
52820   arg3 = jarg3 ? true : false;
52821   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52822   {
52823     try {
52824       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52825     } catch (std::out_of_range& e) {
52826       {
52827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52828       };
52829     } catch (std::exception& e) {
52830       {
52831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (...) {
52834       {
52835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52836       };
52837     }
52838   }
52839 }
52840
52841
52842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52843   void * jresult ;
52844   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52845
52846   {
52847     try {
52848       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52849     } catch (std::out_of_range& e) {
52850       {
52851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52852       };
52853     } catch (std::exception& e) {
52854       {
52855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52856       };
52857     } catch (...) {
52858       {
52859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52860       };
52861     }
52862   }
52863   jresult = (void *)result;
52864   return jresult;
52865 }
52866
52867
52868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52869   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52870
52871   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52872   {
52873     try {
52874       delete arg1;
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52882       };
52883     } catch (...) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52886       };
52887     }
52888   }
52889 }
52890
52891
52892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52893   void * jresult ;
52894   Dali::Timer *result = 0 ;
52895
52896   {
52897     try {
52898       result = (Dali::Timer *)new Dali::Timer();
52899     } catch (std::out_of_range& e) {
52900       {
52901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (std::exception& e) {
52904       {
52905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52906       };
52907     } catch (...) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52910       };
52911     }
52912   }
52913   jresult = (void *)result;
52914   return jresult;
52915 }
52916
52917
52918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52919   void * jresult ;
52920   unsigned int arg1 ;
52921   Dali::Timer result;
52922
52923   arg1 = (unsigned int)jarg1;
52924   {
52925     try {
52926       result = Dali::Timer::New(arg1);
52927     } catch (std::out_of_range& e) {
52928       {
52929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52930       };
52931     } catch (std::exception& e) {
52932       {
52933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (...) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52938       };
52939     }
52940   }
52941   jresult = new Dali::Timer((const Dali::Timer &)result);
52942   return jresult;
52943 }
52944
52945
52946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52947   void * jresult ;
52948   Dali::Timer *arg1 = 0 ;
52949   Dali::Timer *result = 0 ;
52950
52951   arg1 = (Dali::Timer *)jarg1;
52952   if (!arg1) {
52953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52954     return 0;
52955   }
52956   {
52957     try {
52958       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52959     } catch (std::out_of_range& e) {
52960       {
52961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52962       };
52963     } catch (std::exception& e) {
52964       {
52965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52966       };
52967     } catch (...) {
52968       {
52969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52970       };
52971     }
52972   }
52973   jresult = (void *)result;
52974   return jresult;
52975 }
52976
52977
52978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52979   void * jresult ;
52980   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52981   Dali::Timer *arg2 = 0 ;
52982   Dali::Timer *result = 0 ;
52983
52984   arg1 = (Dali::Timer *)jarg1;
52985   arg2 = (Dali::Timer *)jarg2;
52986   if (!arg2) {
52987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52988     return 0;
52989   }
52990   {
52991     try {
52992       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53004       };
53005     }
53006   }
53007   jresult = (void *)result;
53008   return jresult;
53009 }
53010
53011
53012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
53013   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53014
53015   arg1 = (Dali::Timer *)jarg1;
53016   {
53017     try {
53018       delete arg1;
53019     } catch (std::out_of_range& e) {
53020       {
53021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53022       };
53023     } catch (std::exception& e) {
53024       {
53025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53026       };
53027     } catch (...) {
53028       {
53029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53030       };
53031     }
53032   }
53033 }
53034
53035
53036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
53037   void * jresult ;
53038   Dali::BaseHandle arg1 ;
53039   Dali::BaseHandle *argp1 ;
53040   Dali::Timer result;
53041
53042   argp1 = (Dali::BaseHandle *)jarg1;
53043   if (!argp1) {
53044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53045     return 0;
53046   }
53047   arg1 = *argp1;
53048   {
53049     try {
53050       result = Dali::Timer::DownCast(arg1);
53051     } catch (std::out_of_range& e) {
53052       {
53053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (std::exception& e) {
53056       {
53057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065   jresult = new Dali::Timer((const Dali::Timer &)result);
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
53071   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53072
53073   arg1 = (Dali::Timer *)jarg1;
53074   {
53075     try {
53076       (arg1)->Start();
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53088       };
53089     }
53090   }
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53095   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53096
53097   arg1 = (Dali::Timer *)jarg1;
53098   {
53099     try {
53100       (arg1)->Stop();
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (...) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53112       };
53113     }
53114   }
53115 }
53116
53117
53118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53119   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53120   unsigned int arg2 ;
53121
53122   arg1 = (Dali::Timer *)jarg1;
53123   arg2 = (unsigned int)jarg2;
53124   {
53125     try {
53126       (arg1)->SetInterval(arg2);
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53134       };
53135     } catch (...) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53138       };
53139     }
53140   }
53141 }
53142
53143
53144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53145   unsigned int jresult ;
53146   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53147   unsigned int result;
53148
53149   arg1 = (Dali::Timer *)jarg1;
53150   {
53151     try {
53152       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167   jresult = result;
53168   return jresult;
53169 }
53170
53171
53172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53173   unsigned int jresult ;
53174   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53175   bool result;
53176
53177   arg1 = (Dali::Timer *)jarg1;
53178   {
53179     try {
53180       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53192       };
53193     }
53194   }
53195   jresult = result;
53196   return jresult;
53197 }
53198
53199
53200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53201   void * jresult ;
53202   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53203   Dali::Timer::TimerSignalType *result = 0 ;
53204
53205   arg1 = (Dali::Timer *)jarg1;
53206   {
53207     try {
53208       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53209     } catch (std::out_of_range& e) {
53210       {
53211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (std::exception& e) {
53214       {
53215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53216       };
53217     } catch (...) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53220       };
53221     }
53222   }
53223   jresult = (void *)result;
53224   return jresult;
53225 }
53226
53227
53228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53229   void * jresult ;
53230   Dali::DragAndDropDetector *result = 0 ;
53231
53232   {
53233     try {
53234       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53246       };
53247     }
53248   }
53249   jresult = (void *)result;
53250   return jresult;
53251 }
53252
53253
53254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53255   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53256
53257   arg1 = (Dali::DragAndDropDetector *)jarg1;
53258   {
53259     try {
53260       delete arg1;
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275 }
53276
53277
53278 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53279   char * jresult ;
53280   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53281   std::string *result = 0 ;
53282
53283   arg1 = (Dali::DragAndDropDetector *)jarg1;
53284   {
53285     try {
53286       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (...) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53298       };
53299     }
53300   }
53301   jresult = SWIG_csharp_string_callback(result->c_str());
53302   return jresult;
53303 }
53304
53305
53306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53307   void * jresult ;
53308   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53309   Dali::Vector2 result;
53310
53311   arg1 = (Dali::DragAndDropDetector *)jarg1;
53312   {
53313     try {
53314       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53315     } catch (std::out_of_range& e) {
53316       {
53317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53318       };
53319     } catch (std::exception& e) {
53320       {
53321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53322       };
53323     } catch (...) {
53324       {
53325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53326       };
53327     }
53328   }
53329   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53335   void * jresult ;
53336   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53337   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53338
53339   arg1 = (Dali::DragAndDropDetector *)jarg1;
53340   {
53341     try {
53342       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53354       };
53355     }
53356   }
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53363   void * jresult ;
53364   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53365   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53366
53367   arg1 = (Dali::DragAndDropDetector *)jarg1;
53368   {
53369     try {
53370       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53371     } catch (std::out_of_range& e) {
53372       {
53373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53374       };
53375     } catch (std::exception& e) {
53376       {
53377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53378       };
53379     } catch (...) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53382       };
53383     }
53384   }
53385   jresult = (void *)result;
53386   return jresult;
53387 }
53388
53389
53390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53391   void * jresult ;
53392   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53393   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53394
53395   arg1 = (Dali::DragAndDropDetector *)jarg1;
53396   {
53397     try {
53398       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53399     } catch (std::out_of_range& e) {
53400       {
53401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53402       };
53403     } catch (std::exception& e) {
53404       {
53405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53410       };
53411     }
53412   }
53413   jresult = (void *)result;
53414   return jresult;
53415 }
53416
53417
53418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53419   void * jresult ;
53420   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53421   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53422
53423   arg1 = (Dali::DragAndDropDetector *)jarg1;
53424   {
53425     try {
53426       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53438       };
53439     }
53440   }
53441   jresult = (void *)result;
53442   return jresult;
53443 }
53444
53445
53446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53447   void * jresult ;
53448   Dali::ApplicationExtensions *result = 0 ;
53449
53450   {
53451     try {
53452       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53453     } catch (std::out_of_range& e) {
53454       {
53455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53456       };
53457     } catch (std::exception& e) {
53458       {
53459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53460       };
53461     } catch (...) {
53462       {
53463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53464       };
53465     }
53466   }
53467   jresult = (void *)result;
53468   return jresult;
53469 }
53470
53471
53472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53473   void * jresult ;
53474   Dali::Application *arg1 = (Dali::Application *) 0 ;
53475   Dali::ApplicationExtensions *result = 0 ;
53476
53477   arg1 = (Dali::Application *)jarg1;
53478   {
53479     try {
53480       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53481     } catch (std::out_of_range& e) {
53482       {
53483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53484       };
53485     } catch (std::exception& e) {
53486       {
53487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (...) {
53490       {
53491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53492       };
53493     }
53494   }
53495   jresult = (void *)result;
53496   return jresult;
53497 }
53498
53499
53500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53501   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53502
53503   arg1 = (Dali::ApplicationExtensions *)jarg1;
53504   {
53505     try {
53506       delete arg1;
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53514       };
53515     } catch (...) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53518       };
53519     }
53520   }
53521 }
53522
53523
53524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53525   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53526
53527   arg1 = (Dali::ApplicationExtensions *)jarg1;
53528   {
53529     try {
53530       (arg1)->Init();
53531     } catch (std::out_of_range& e) {
53532       {
53533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53534       };
53535     } catch (std::exception& e) {
53536       {
53537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53538       };
53539     } catch (...) {
53540       {
53541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53542       };
53543     }
53544   }
53545 }
53546
53547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
53548   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53549
53550   arg1 = (Dali::ApplicationExtensions *)jarg1;
53551   {
53552     try {
53553       (arg1)->Start();
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53561       };
53562     } catch (...) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53565       };
53566     }
53567   }
53568 }
53569
53570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53571   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53572
53573   arg1 = (Dali::ApplicationExtensions *)jarg1;
53574   {
53575     try {
53576       (arg1)->Terminate();
53577     } catch (std::out_of_range& e) {
53578       {
53579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53580       };
53581     } catch (std::exception& e) {
53582       {
53583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (...) {
53586       {
53587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53588       };
53589     }
53590   }
53591 }
53592
53593
53594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53595   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53596
53597   arg1 = (Dali::ApplicationExtensions *)jarg1;
53598   {
53599     try {
53600       (arg1)->Pause();
53601     } catch (std::out_of_range& e) {
53602       {
53603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53604       };
53605     } catch (std::exception& e) {
53606       {
53607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (...) {
53610       {
53611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53612       };
53613     }
53614   }
53615 }
53616
53617
53618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53619   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53620
53621   arg1 = (Dali::ApplicationExtensions *)jarg1;
53622   {
53623     try {
53624       (arg1)->Resume();
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53636       };
53637     }
53638   }
53639 }
53640
53641
53642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53643   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53644
53645   arg1 = (Dali::ApplicationExtensions *)jarg1;
53646   {
53647     try {
53648       (arg1)->LanguageChange();
53649     } catch (std::out_of_range& e) {
53650       {
53651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (std::exception& e) {
53654       {
53655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663 }
53664
53665
53666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53667   void * jresult ;
53668   Dali::PositionSize arg1 ;
53669   std::string *arg2 = 0 ;
53670   bool arg3 ;
53671   Dali::PositionSize *argp1 ;
53672   Dali::Window result;
53673
53674   argp1 = (Dali::PositionSize *)jarg1;
53675   if (!argp1) {
53676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53677     return 0;
53678   }
53679   arg1 = *argp1;
53680   if (!jarg2) {
53681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53682     return 0;
53683   }
53684   std::string arg2_str(jarg2);
53685   arg2 = &arg2_str;
53686   arg3 = jarg3 ? true : false;
53687   {
53688     try {
53689       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53690     } catch (std::out_of_range& e) {
53691       {
53692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53693       };
53694     } catch (std::exception& e) {
53695       {
53696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53697       };
53698     } catch (...) {
53699       {
53700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53701       };
53702     }
53703   }
53704   jresult = new Dali::Window((const Dali::Window &)result);
53705
53706   //argout typemap for const std::string&
53707
53708   return jresult;
53709 }
53710
53711
53712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53713   void * jresult ;
53714   Dali::PositionSize arg1 ;
53715   std::string *arg2 = 0 ;
53716   Dali::PositionSize *argp1 ;
53717   Dali::Window result;
53718
53719   argp1 = (Dali::PositionSize *)jarg1;
53720   if (!argp1) {
53721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53722     return 0;
53723   }
53724   arg1 = *argp1;
53725   if (!jarg2) {
53726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53727     return 0;
53728   }
53729   std::string arg2_str(jarg2);
53730   arg2 = &arg2_str;
53731   {
53732     try {
53733       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53734     } catch (std::out_of_range& e) {
53735       {
53736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53737       };
53738     } catch (std::exception& e) {
53739       {
53740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53741       };
53742     } catch (...) {
53743       {
53744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53745       };
53746     }
53747   }
53748   jresult = new Dali::Window((const Dali::Window &)result);
53749
53750   //argout typemap for const std::string&
53751
53752   return jresult;
53753 }
53754
53755
53756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53757   void * jresult ;
53758   Dali::PositionSize arg1 ;
53759   std::string *arg2 = 0 ;
53760   std::string *arg3 = 0 ;
53761   bool arg4 ;
53762   Dali::PositionSize *argp1 ;
53763   Dali::Window result;
53764
53765   argp1 = (Dali::PositionSize *)jarg1;
53766   if (!argp1) {
53767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53768     return 0;
53769   }
53770   arg1 = *argp1;
53771   if (!jarg2) {
53772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53773     return 0;
53774   }
53775   std::string arg2_str(jarg2);
53776   arg2 = &arg2_str;
53777   if (!jarg3) {
53778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53779     return 0;
53780   }
53781   std::string arg3_str(jarg3);
53782   arg3 = &arg3_str;
53783   arg4 = jarg4 ? true : false;
53784   {
53785     try {
53786       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53787     } catch (std::out_of_range& e) {
53788       {
53789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53790       };
53791     } catch (std::exception& e) {
53792       {
53793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53794       };
53795     } catch (...) {
53796       {
53797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53798       };
53799     }
53800   }
53801   jresult = new Dali::Window((const Dali::Window &)result);
53802
53803   //argout typemap for const std::string&
53804
53805
53806   //argout typemap for const std::string&
53807
53808   return jresult;
53809 }
53810
53811
53812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53813   void * jresult ;
53814   Dali::PositionSize arg1 ;
53815   std::string *arg2 = 0 ;
53816   std::string *arg3 = 0 ;
53817   Dali::PositionSize *argp1 ;
53818   Dali::Window result;
53819
53820   argp1 = (Dali::PositionSize *)jarg1;
53821   if (!argp1) {
53822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53823     return 0;
53824   }
53825   arg1 = *argp1;
53826   if (!jarg2) {
53827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53828     return 0;
53829   }
53830   std::string arg2_str(jarg2);
53831   arg2 = &arg2_str;
53832   if (!jarg3) {
53833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53834     return 0;
53835   }
53836   std::string arg3_str(jarg3);
53837   arg3 = &arg3_str;
53838   {
53839     try {
53840       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53841     } catch (std::out_of_range& e) {
53842       {
53843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53844       };
53845     } catch (std::exception& e) {
53846       {
53847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53852       };
53853     }
53854   }
53855   jresult = new Dali::Window((const Dali::Window &)result);
53856
53857   //argout typemap for const std::string&
53858
53859
53860   //argout typemap for const std::string&
53861
53862   return jresult;
53863 }
53864
53865
53866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53867   void * jresult ;
53868   Dali::Window *result = 0 ;
53869
53870   {
53871     try {
53872       result = (Dali::Window *)new Dali::Window();
53873     } catch (std::out_of_range& e) {
53874       {
53875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (std::exception& e) {
53878       {
53879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (...) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53884       };
53885     }
53886   }
53887   jresult = (void *)result;
53888   return jresult;
53889 }
53890
53891
53892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53893   Dali::Window *arg1 = (Dali::Window *) 0 ;
53894
53895   arg1 = (Dali::Window *)jarg1;
53896   {
53897     try {
53898       delete arg1;
53899     } catch (std::out_of_range& e) {
53900       {
53901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53902       };
53903     } catch (std::exception& e) {
53904       {
53905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53910       };
53911     }
53912   }
53913 }
53914
53915
53916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53917   void * jresult ;
53918   Dali::Window *arg1 = 0 ;
53919   Dali::Window *result = 0 ;
53920
53921   arg1 = (Dali::Window *)jarg1;
53922   if (!arg1) {
53923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53924     return 0;
53925   }
53926   {
53927     try {
53928       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53929     } catch (std::out_of_range& e) {
53930       {
53931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53932       };
53933     } catch (std::exception& e) {
53934       {
53935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (...) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53940       };
53941     }
53942   }
53943   jresult = (void *)result;
53944   return jresult;
53945 }
53946
53947
53948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53949   void * jresult ;
53950   Dali::Window *arg1 = (Dali::Window *) 0 ;
53951   Dali::Window *arg2 = 0 ;
53952   Dali::Window *result = 0 ;
53953
53954   arg1 = (Dali::Window *)jarg1;
53955   arg2 = (Dali::Window *)jarg2;
53956   if (!arg2) {
53957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53958     return 0;
53959   }
53960   {
53961     try {
53962       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53970       };
53971     } catch (...) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53974       };
53975     }
53976   }
53977   jresult = (void *)result;
53978   return jresult;
53979 }
53980
53981
53982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53983   Dali::Window *arg1 = (Dali::Window *) 0 ;
53984   Dali::Window::IndicatorVisibleMode arg2 ;
53985
53986   arg1 = (Dali::Window *)jarg1;
53987   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53988   {
53989     try {
53990       (arg1)->ShowIndicator(arg2);
53991     } catch (std::out_of_range& e) {
53992       {
53993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53994       };
53995     } catch (std::exception& e) {
53996       {
53997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (...) {
54000       {
54001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54002       };
54003     }
54004   }
54005 }
54006
54007
54008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
54009   Dali::Window *arg1 = (Dali::Window *) 0 ;
54010   Dali::Window::IndicatorBgOpacity arg2 ;
54011
54012   arg1 = (Dali::Window *)jarg1;
54013   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
54014   {
54015     try {
54016       (arg1)->SetIndicatorBgOpacity(arg2);
54017     } catch (std::out_of_range& e) {
54018       {
54019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54020       };
54021     } catch (std::exception& e) {
54022       {
54023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (...) {
54026       {
54027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54028       };
54029     }
54030   }
54031 }
54032
54033
54034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
54035   Dali::Window *arg1 = (Dali::Window *) 0 ;
54036   Dali::Window::WindowOrientation arg2 ;
54037
54038   arg1 = (Dali::Window *)jarg1;
54039   arg2 = (Dali::Window::WindowOrientation)jarg2;
54040   {
54041     try {
54042       (arg1)->RotateIndicator(arg2);
54043     } catch (std::out_of_range& e) {
54044       {
54045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54046       };
54047     } catch (std::exception& e) {
54048       {
54049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54050       };
54051     } catch (...) {
54052       {
54053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54054       };
54055     }
54056   }
54057 }
54058
54059
54060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
54061   Dali::Window *arg1 = (Dali::Window *) 0 ;
54062   std::string arg2 ;
54063   std::string arg3 ;
54064
54065   arg1 = (Dali::Window *)jarg1;
54066   if (!jarg2) {
54067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54068     return ;
54069   }
54070   (&arg2)->assign(jarg2);
54071   if (!jarg3) {
54072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54073     return ;
54074   }
54075   (&arg3)->assign(jarg3);
54076   {
54077     try {
54078       (arg1)->SetClass(arg2,arg3);
54079     } catch (std::out_of_range& e) {
54080       {
54081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54082       };
54083     } catch (std::exception& e) {
54084       {
54085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (...) {
54088       {
54089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54090       };
54091     }
54092   }
54093 }
54094
54095
54096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
54097   Dali::Window *arg1 = (Dali::Window *) 0 ;
54098
54099   arg1 = (Dali::Window *)jarg1;
54100   {
54101     try {
54102       (arg1)->Raise();
54103     } catch (std::out_of_range& e) {
54104       {
54105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54106       };
54107     } catch (std::exception& e) {
54108       {
54109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54110       };
54111     } catch (...) {
54112       {
54113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54114       };
54115     }
54116   }
54117 }
54118
54119
54120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54121   Dali::Window *arg1 = (Dali::Window *) 0 ;
54122
54123   arg1 = (Dali::Window *)jarg1;
54124   {
54125     try {
54126       (arg1)->Lower();
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (...) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54138       };
54139     }
54140   }
54141 }
54142
54143
54144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54145   Dali::Window *arg1 = (Dali::Window *) 0 ;
54146
54147   arg1 = (Dali::Window *)jarg1;
54148   {
54149     try {
54150       (arg1)->Activate();
54151     } catch (std::out_of_range& e) {
54152       {
54153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54154       };
54155     } catch (std::exception& e) {
54156       {
54157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (...) {
54160       {
54161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54162       };
54163     }
54164   }
54165 }
54166
54167
54168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54169   Dali::Window *arg1 = (Dali::Window *) 0 ;
54170   Dali::Window::WindowOrientation arg2 ;
54171
54172   arg1 = (Dali::Window *)jarg1;
54173   arg2 = (Dali::Window::WindowOrientation)jarg2;
54174   {
54175     try {
54176       (arg1)->AddAvailableOrientation(arg2);
54177     } catch (std::out_of_range& e) {
54178       {
54179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54180       };
54181     } catch (std::exception& e) {
54182       {
54183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (...) {
54186       {
54187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54188       };
54189     }
54190   }
54191 }
54192
54193
54194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54195   Dali::Window *arg1 = (Dali::Window *) 0 ;
54196   Dali::Window::WindowOrientation arg2 ;
54197
54198   arg1 = (Dali::Window *)jarg1;
54199   arg2 = (Dali::Window::WindowOrientation)jarg2;
54200   {
54201     try {
54202       (arg1)->RemoveAvailableOrientation(arg2);
54203     } catch (std::out_of_range& e) {
54204       {
54205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54206       };
54207     } catch (std::exception& e) {
54208       {
54209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54210       };
54211     } catch (...) {
54212       {
54213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54214       };
54215     }
54216   }
54217 }
54218
54219
54220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54221   Dali::Window *arg1 = (Dali::Window *) 0 ;
54222   Dali::Window::WindowOrientation arg2 ;
54223
54224   arg1 = (Dali::Window *)jarg1;
54225   arg2 = (Dali::Window::WindowOrientation)jarg2;
54226   {
54227     try {
54228       (arg1)->SetPreferredOrientation(arg2);
54229     } catch (std::out_of_range& e) {
54230       {
54231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54232       };
54233     } catch (std::exception& e) {
54234       {
54235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54236       };
54237     } catch (...) {
54238       {
54239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54240       };
54241     }
54242   }
54243 }
54244
54245
54246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54247   int jresult ;
54248   Dali::Window *arg1 = (Dali::Window *) 0 ;
54249   Dali::Window::WindowOrientation result;
54250
54251   arg1 = (Dali::Window *)jarg1;
54252   {
54253     try {
54254       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54255     } catch (std::out_of_range& e) {
54256       {
54257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (std::exception& e) {
54260       {
54261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (...) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54266       };
54267     }
54268   }
54269   jresult = (int)result;
54270   return jresult;
54271 }
54272
54273
54274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54275   void * jresult ;
54276   Dali::Window *arg1 = (Dali::Window *) 0 ;
54277   Dali::DragAndDropDetector result;
54278
54279   arg1 = (Dali::Window *)jarg1;
54280   {
54281     try {
54282       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54283     } catch (std::out_of_range& e) {
54284       {
54285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54286       };
54287     } catch (std::exception& e) {
54288       {
54289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54290       };
54291     } catch (...) {
54292       {
54293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54294       };
54295     }
54296   }
54297   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54298   return jresult;
54299 }
54300
54301
54302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54303   void * jresult ;
54304   Dali::Window *arg1 = (Dali::Window *) 0 ;
54305   Dali::Any result;
54306
54307   arg1 = (Dali::Window *)jarg1;
54308   {
54309     try {
54310       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54311     } catch (std::out_of_range& e) {
54312       {
54313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54314       };
54315     } catch (std::exception& e) {
54316       {
54317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54322       };
54323     }
54324   }
54325   jresult = new Dali::Any((const Dali::Any &)result);
54326   return jresult;
54327 }
54328
54329
54330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54331   void * jresult ;
54332   Dali::Window arg1 ;
54333   Dali::Window *argp1 ;
54334   Dali::DevelWindow::FocusSignalType *result = 0 ;
54335
54336   argp1 = (Dali::Window *)jarg1;
54337   if (!argp1) {
54338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54339     return 0;
54340   }
54341   arg1 = *argp1;
54342   {
54343     try {
54344       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54345     } catch (std::out_of_range& e) {
54346       {
54347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (std::exception& e) {
54350       {
54351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (...) {
54354       {
54355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54356       };
54357     }
54358   }
54359   jresult = (void *)result;
54360   return jresult;
54361 }
54362
54363
54364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54365   Dali::Window arg1 ;
54366   bool arg2 ;
54367   Dali::Window *argp1 ;
54368
54369   argp1 = (Dali::Window *)jarg1;
54370   if (!argp1) {
54371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54372     return ;
54373   }
54374   arg1 = *argp1;
54375   arg2 = jarg2 ? true : false;
54376   {
54377     try {
54378       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (...) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54390       };
54391     }
54392   }
54393 }
54394
54395
54396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54397   unsigned int jresult ;
54398   Dali::Window arg1 ;
54399   Dali::Window *argp1 ;
54400   bool result;
54401
54402   argp1 = (Dali::Window *)jarg1;
54403   if (!argp1) {
54404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54405     return 0;
54406   }
54407   arg1 = *argp1;
54408   {
54409     try {
54410       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54411     } catch (std::out_of_range& e) {
54412       {
54413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54414       };
54415     } catch (std::exception& e) {
54416       {
54417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54418       };
54419     } catch (...) {
54420       {
54421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54422       };
54423     }
54424   }
54425   jresult = result;
54426   return jresult;
54427 }
54428
54429
54430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54431   Dali::Window arg1 ;
54432   Dali::Window *argp1 ;
54433
54434   argp1 = (Dali::Window *)jarg1;
54435   if (!argp1) {
54436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54437     return ;
54438   }
54439   arg1 = *argp1;
54440   {
54441     try {
54442       Dali::DevelWindow::Show(arg1);
54443     } catch (std::out_of_range& e) {
54444       {
54445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54446       };
54447     } catch (std::exception& e) {
54448       {
54449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (...) {
54452       {
54453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54454       };
54455     }
54456   }
54457 }
54458
54459
54460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54461   Dali::Window arg1 ;
54462   Dali::Window *argp1 ;
54463
54464   argp1 = (Dali::Window *)jarg1;
54465   if (!argp1) {
54466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54467     return ;
54468   }
54469   arg1 = *argp1;
54470   {
54471     try {
54472       Dali::DevelWindow::Hide(arg1);
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54484       };
54485     }
54486   }
54487 }
54488
54489
54490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54491   unsigned int jresult ;
54492   Dali::Window arg1 ;
54493   Dali::Window *argp1 ;
54494   bool result;
54495
54496   argp1 = (Dali::Window *)jarg1;
54497   if (!argp1) {
54498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54499     return 0;
54500   }
54501   arg1 = *argp1;
54502   {
54503     try {
54504       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54505     } catch (std::out_of_range& e) {
54506       {
54507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54508       };
54509     } catch (std::exception& e) {
54510       {
54511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (...) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54516       };
54517     }
54518   }
54519   jresult = result;
54520   return jresult;
54521 }
54522
54523
54524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54525   unsigned int jresult ;
54526   Dali::Window arg1 ;
54527   Dali::Window *argp1 ;
54528   unsigned int result;
54529
54530   argp1 = (Dali::Window *)jarg1;
54531   if (!argp1) {
54532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54533     return 0;
54534   }
54535   arg1 = *argp1;
54536   {
54537     try {
54538       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54539     } catch (std::out_of_range& e) {
54540       {
54541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (std::exception& e) {
54544       {
54545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54550       };
54551     }
54552   }
54553   jresult = result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54559   char * jresult ;
54560   Dali::Window arg1 ;
54561   unsigned int arg2 ;
54562   Dali::Window *argp1 ;
54563   std::string result;
54564
54565   argp1 = (Dali::Window *)jarg1;
54566   if (!argp1) {
54567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54568     return 0;
54569   }
54570   arg1 = *argp1;
54571   arg2 = (unsigned int)jarg2;
54572   {
54573     try {
54574       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54575     } catch (std::out_of_range& e) {
54576       {
54577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54578       };
54579     } catch (std::exception& e) {
54580       {
54581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54582       };
54583     } catch (...) {
54584       {
54585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54586       };
54587     }
54588   }
54589   jresult = SWIG_csharp_string_callback((&result)->c_str());
54590   return jresult;
54591 }
54592
54593
54594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54595   unsigned int jresult ;
54596   Dali::Window arg1 ;
54597   std::string *arg2 = 0 ;
54598   std::string *arg3 = 0 ;
54599   Dali::Window *argp1 ;
54600   unsigned int result;
54601
54602   argp1 = (Dali::Window *)jarg1;
54603   if (!argp1) {
54604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54605     return 0;
54606   }
54607   arg1 = *argp1;
54608   if (!jarg2) {
54609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54610     return 0;
54611   }
54612   std::string arg2_str(jarg2);
54613   arg2 = &arg2_str;
54614   if (!jarg3) {
54615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54616     return 0;
54617   }
54618   std::string arg3_str(jarg3);
54619   arg3 = &arg3_str;
54620   {
54621     try {
54622       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54623     } catch (std::out_of_range& e) {
54624       {
54625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54626       };
54627     } catch (std::exception& e) {
54628       {
54629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54630       };
54631     } catch (...) {
54632       {
54633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54634       };
54635     }
54636   }
54637   jresult = result;
54638
54639   //argout typemap for const std::string&
54640
54641
54642   //argout typemap for const std::string&
54643
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54649   unsigned int jresult ;
54650   Dali::Window arg1 ;
54651   unsigned int arg2 ;
54652   Dali::Window *argp1 ;
54653   bool result;
54654
54655   argp1 = (Dali::Window *)jarg1;
54656   if (!argp1) {
54657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54658     return 0;
54659   }
54660   arg1 = *argp1;
54661   arg2 = (unsigned int)jarg2;
54662   {
54663     try {
54664       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54665     } catch (std::out_of_range& e) {
54666       {
54667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54668       };
54669     } catch (std::exception& e) {
54670       {
54671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54672       };
54673     } catch (...) {
54674       {
54675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54676       };
54677     }
54678   }
54679   jresult = result;
54680   return jresult;
54681 }
54682
54683
54684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54685   unsigned int jresult ;
54686   Dali::Window arg1 ;
54687   unsigned int arg2 ;
54688   std::string *arg3 = 0 ;
54689   Dali::Window *argp1 ;
54690   bool result;
54691
54692   argp1 = (Dali::Window *)jarg1;
54693   if (!argp1) {
54694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54695     return 0;
54696   }
54697   arg1 = *argp1;
54698   arg2 = (unsigned int)jarg2;
54699   if (!jarg3) {
54700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54701     return 0;
54702   }
54703   std::string arg3_str(jarg3);
54704   arg3 = &arg3_str;
54705   {
54706     try {
54707       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54708     } catch (std::out_of_range& e) {
54709       {
54710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54711       };
54712     } catch (std::exception& e) {
54713       {
54714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54715       };
54716     } catch (...) {
54717       {
54718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54719       };
54720     }
54721   }
54722   jresult = result;
54723
54724   //argout typemap for const std::string&
54725
54726   return jresult;
54727 }
54728
54729
54730 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54731   char * jresult ;
54732   Dali::Window arg1 ;
54733   unsigned int arg2 ;
54734   Dali::Window *argp1 ;
54735   std::string result;
54736
54737   argp1 = (Dali::Window *)jarg1;
54738   if (!argp1) {
54739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54740     return 0;
54741   }
54742   arg1 = *argp1;
54743   arg2 = (unsigned int)jarg2;
54744   {
54745     try {
54746       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54747     } catch (std::out_of_range& e) {
54748       {
54749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (std::exception& e) {
54752       {
54753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (...) {
54756       {
54757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54758       };
54759     }
54760   }
54761   jresult = SWIG_csharp_string_callback((&result)->c_str());
54762   return jresult;
54763 }
54764
54765
54766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54767   unsigned int jresult ;
54768   Dali::Window arg1 ;
54769   std::string *arg2 = 0 ;
54770   Dali::Window *argp1 ;
54771   unsigned int result;
54772
54773   argp1 = (Dali::Window *)jarg1;
54774   if (!argp1) {
54775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54776     return 0;
54777   }
54778   arg1 = *argp1;
54779   if (!jarg2) {
54780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54781     return 0;
54782   }
54783   std::string arg2_str(jarg2);
54784   arg2 = &arg2_str;
54785   {
54786     try {
54787       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (...) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54799       };
54800     }
54801   }
54802   jresult = result;
54803
54804   //argout typemap for const std::string&
54805
54806   return jresult;
54807 }
54808
54809
54810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54811   Dali::Window arg1 ;
54812   Dali::Rect< int > *arg2 = 0 ;
54813   Dali::Window *argp1 ;
54814
54815   argp1 = (Dali::Window *)jarg1;
54816   if (!argp1) {
54817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54818     return ;
54819   }
54820   arg1 = *argp1;
54821   arg2 = (Dali::Rect< int > *)jarg2;
54822   if (!arg2) {
54823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54824     return ;
54825   }
54826   {
54827     try {
54828       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54829     } catch (std::out_of_range& e) {
54830       {
54831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (std::exception& e) {
54834       {
54835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54840       };
54841     }
54842   }
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54847   Dali::Window arg1 ;
54848   Dali::DevelWindow::Type arg2 ;
54849   Dali::Window *argp1 ;
54850
54851   argp1 = (Dali::Window *)jarg1;
54852   if (!argp1) {
54853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54854     return ;
54855   }
54856   arg1 = *argp1;
54857   arg2 = (Dali::DevelWindow::Type)jarg2;
54858   {
54859     try {
54860       Dali::DevelWindow::SetType(arg1,arg2);
54861     } catch (std::out_of_range& e) {
54862       {
54863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54864       };
54865     } catch (std::exception& e) {
54866       {
54867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54868       };
54869     } catch (...) {
54870       {
54871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54872       };
54873     }
54874   }
54875 }
54876
54877
54878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54879   int jresult ;
54880   Dali::Window arg1 ;
54881   Dali::Window *argp1 ;
54882   Dali::DevelWindow::Type result;
54883
54884   argp1 = (Dali::Window *)jarg1;
54885   if (!argp1) {
54886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54887     return 0;
54888   }
54889   arg1 = *argp1;
54890   {
54891     try {
54892       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54893     } catch (std::out_of_range& e) {
54894       {
54895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54896       };
54897     } catch (std::exception& e) {
54898       {
54899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54904       };
54905     }
54906   }
54907   jresult = (int)result;
54908   return jresult;
54909 }
54910
54911
54912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54913   unsigned int jresult ;
54914   Dali::Window arg1 ;
54915   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54916   Dali::Window *argp1 ;
54917   bool result;
54918
54919   argp1 = (Dali::Window *)jarg1;
54920   if (!argp1) {
54921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54922     return 0;
54923   }
54924   arg1 = *argp1;
54925   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54926   {
54927     try {
54928       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54929     } catch (std::out_of_range& e) {
54930       {
54931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54932       };
54933     } catch (std::exception& e) {
54934       {
54935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54936       };
54937     } catch (...) {
54938       {
54939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54940       };
54941     }
54942   }
54943   jresult = result;
54944   return jresult;
54945 }
54946
54947
54948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54949   int jresult ;
54950   Dali::Window arg1 ;
54951   Dali::Window *argp1 ;
54952   Dali::DevelWindow::NotificationLevel::Type result;
54953
54954   argp1 = (Dali::Window *)jarg1;
54955   if (!argp1) {
54956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54957     return 0;
54958   }
54959   arg1 = *argp1;
54960   {
54961     try {
54962       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (...) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54974       };
54975     }
54976   }
54977   jresult = (int)result;
54978   return jresult;
54979 }
54980
54981
54982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54983   Dali::Window arg1 ;
54984   bool arg2 ;
54985   Dali::Window *argp1 ;
54986
54987   argp1 = (Dali::Window *)jarg1;
54988   if (!argp1) {
54989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54990     return ;
54991   }
54992   arg1 = *argp1;
54993   arg2 = jarg2 ? true : false;
54994   {
54995     try {
54996       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54997     } catch (std::out_of_range& e) {
54998       {
54999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55000       };
55001     } catch (std::exception& e) {
55002       {
55003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55004       };
55005     } catch (...) {
55006       {
55007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55008       };
55009     }
55010   }
55011 }
55012
55013
55014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
55015   unsigned int jresult ;
55016   Dali::Window arg1 ;
55017   Dali::Window *argp1 ;
55018   bool result;
55019
55020   argp1 = (Dali::Window *)jarg1;
55021   if (!argp1) {
55022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55023     return 0;
55024   }
55025   arg1 = *argp1;
55026   {
55027     try {
55028       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
55029     } catch (std::out_of_range& e) {
55030       {
55031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55032       };
55033     } catch (std::exception& e) {
55034       {
55035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55040       };
55041     }
55042   }
55043   jresult = result;
55044   return jresult;
55045 }
55046
55047
55048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
55049   unsigned int jresult ;
55050   Dali::Window arg1 ;
55051   Dali::DevelWindow::ScreenMode::Type arg2 ;
55052   Dali::Window *argp1 ;
55053   bool result;
55054
55055   argp1 = (Dali::Window *)jarg1;
55056   if (!argp1) {
55057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55058     return 0;
55059   }
55060   arg1 = *argp1;
55061   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
55062   {
55063     try {
55064       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
55065     } catch (std::out_of_range& e) {
55066       {
55067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55068       };
55069     } catch (std::exception& e) {
55070       {
55071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55072       };
55073     } catch (...) {
55074       {
55075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55076       };
55077     }
55078   }
55079   jresult = result;
55080   return jresult;
55081 }
55082
55083
55084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
55085   int jresult ;
55086   Dali::Window arg1 ;
55087   Dali::Window *argp1 ;
55088   Dali::DevelWindow::ScreenMode::Type result;
55089
55090   argp1 = (Dali::Window *)jarg1;
55091   if (!argp1) {
55092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55093     return 0;
55094   }
55095   arg1 = *argp1;
55096   {
55097     try {
55098       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
55099     } catch (std::out_of_range& e) {
55100       {
55101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55102       };
55103     } catch (std::exception& e) {
55104       {
55105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55106       };
55107     } catch (...) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55110       };
55111     }
55112   }
55113   jresult = (int)result;
55114   return jresult;
55115 }
55116
55117
55118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55119   unsigned int jresult ;
55120   Dali::Window arg1 ;
55121   int arg2 ;
55122   Dali::Window *argp1 ;
55123   bool result;
55124
55125   argp1 = (Dali::Window *)jarg1;
55126   if (!argp1) {
55127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55128     return 0;
55129   }
55130   arg1 = *argp1;
55131   arg2 = (int)jarg2;
55132   {
55133     try {
55134       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55135     } catch (std::out_of_range& e) {
55136       {
55137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55138       };
55139     } catch (std::exception& e) {
55140       {
55141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55146       };
55147     }
55148   }
55149   jresult = result;
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55155   int jresult ;
55156   Dali::Window arg1 ;
55157   Dali::Window *argp1 ;
55158   int result;
55159
55160   argp1 = (Dali::Window *)jarg1;
55161   if (!argp1) {
55162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55163     return 0;
55164   }
55165   arg1 = *argp1;
55166   {
55167     try {
55168       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55169     } catch (std::out_of_range& e) {
55170       {
55171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (std::exception& e) {
55174       {
55175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183   jresult = result;
55184   return jresult;
55185 }
55186
55187
55188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55189   void * jresult ;
55190   Dali::Application result;
55191
55192   {
55193     try {
55194       result = Dali::Application::New();
55195     } catch (std::out_of_range& e) {
55196       {
55197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55198       };
55199     } catch (std::exception& e) {
55200       {
55201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55202       };
55203     } catch (...) {
55204       {
55205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55206       };
55207     }
55208   }
55209   jresult = new Dali::Application((const Dali::Application &)result);
55210   return jresult;
55211 }
55212
55213
55214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55215   void * jresult ;
55216   int *arg1 = (int *) 0 ;
55217   char ***arg2 ;
55218   Dali::Application result;
55219
55220   {
55221     // Todo generate argv data from the C# args
55222     char **array;         // two dimensional array
55223     int numStrings = 1;     // number of strings
55224     int stringLength = 30;      // max string length.
55225     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55226     argV = array;
55227
55228     // allocate the string data
55229     for( int i=0; i < numStrings; i++)
55230     {
55231       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55232     }
55233     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55234
55235     strcpy( array[0], "dali-csharp-app");
55236
55237     arg1 = &argC;
55238     arg2 = &argV;
55239   }
55240   {
55241     try {
55242       result = Dali::Application::New(arg1,arg2);
55243     } catch (std::out_of_range& e) {
55244       {
55245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55246       };
55247     } catch (std::exception& e) {
55248       {
55249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55250       };
55251     } catch (...) {
55252       {
55253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55254       };
55255     }
55256   }
55257   jresult = new Dali::Application((const Dali::Application &)result);
55258   return jresult;
55259 }
55260
55261
55262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55263   void * jresult ;
55264   int *arg1 = (int *) 0 ;
55265   char ***arg2 ;
55266   std::string *arg3 = 0 ;
55267   Dali::Application result;
55268
55269   {
55270     // Todo generate argv data from the C# args
55271     char **array;         // two dimensional array
55272     int numStrings = 1;     // number of strings
55273     int stringLength = 30;      // max string length.
55274     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55275     argV = array;
55276
55277     // allocate the string data
55278     for( int i=0; i < numStrings; i++)
55279     {
55280       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55281     }
55282     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55283
55284     strcpy( array[0], "dali-csharp-app");
55285
55286     arg1 = &argC;
55287     arg2 = &argV;
55288   }
55289   if (!jarg3) {
55290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55291     return 0;
55292   }
55293   std::string arg3_str(jarg3);
55294   arg3 = &arg3_str;
55295   {
55296     try {
55297       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55298     } catch (std::out_of_range& e) {
55299       {
55300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55301       };
55302     } catch (std::exception& e) {
55303       {
55304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55305       };
55306     } catch (...) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55309       };
55310     }
55311   }
55312   jresult = new Dali::Application((const Dali::Application &)result);
55313
55314   //argout typemap for const std::string&
55315
55316   return jresult;
55317 }
55318
55319
55320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55321   void * jresult ;
55322   int *arg1 = (int *) 0 ;
55323   char ***arg2 ;
55324   std::string *arg3 = 0 ;
55325   Dali::Application::WINDOW_MODE arg4 ;
55326   Dali::Application result;
55327
55328   {
55329     // Todo generate argv data from the C# args
55330     char **array;         // two dimensional array
55331     int numStrings = 1;     // number of strings
55332     int stringLength = 30;      // max string length.
55333     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55334     argV = array;
55335
55336     // allocate the string data
55337     for( int i=0; i < numStrings; i++)
55338     {
55339       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55340     }
55341     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55342
55343     strcpy( array[0], "dali-csharp-app");
55344
55345     arg1 = &argC;
55346     arg2 = &argV;
55347   }
55348   if (!jarg3) {
55349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55350     return 0;
55351   }
55352   std::string arg3_str(jarg3);
55353   arg3 = &arg3_str;
55354   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55355   {
55356     try {
55357       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55358     } catch (std::out_of_range& e) {
55359       {
55360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55361       };
55362     } catch (std::exception& e) {
55363       {
55364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (...) {
55367       {
55368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55369       };
55370     }
55371   }
55372   jresult = new Dali::Application((const Dali::Application &)result);
55373
55374   //argout typemap for const std::string&
55375
55376   return jresult;
55377 }
55378
55379
55380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55381   void * jresult ;
55382   Dali::Application *result = 0 ;
55383
55384   {
55385     try {
55386       result = (Dali::Application *)new Dali::Application();
55387     } catch (std::out_of_range& e) {
55388       {
55389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (std::exception& e) {
55392       {
55393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55398       };
55399     }
55400   }
55401   jresult = (void *)result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55407   void * jresult ;
55408   Dali::Application *arg1 = 0 ;
55409   Dali::Application *result = 0 ;
55410
55411   arg1 = (Dali::Application *)jarg1;
55412   if (!arg1) {
55413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55414     return 0;
55415   }
55416   {
55417     try {
55418       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55419     } catch (std::out_of_range& e) {
55420       {
55421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (std::exception& e) {
55424       {
55425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55430       };
55431     }
55432   }
55433   jresult = (void *)result;
55434   return jresult;
55435 }
55436
55437
55438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55439   void * jresult ;
55440   Dali::Application *arg1 = (Dali::Application *) 0 ;
55441   Dali::Application *arg2 = 0 ;
55442   Dali::Application *result = 0 ;
55443
55444   arg1 = (Dali::Application *)jarg1;
55445   arg2 = (Dali::Application *)jarg2;
55446   if (!arg2) {
55447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55448     return 0;
55449   }
55450   {
55451     try {
55452       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55453     } catch (std::out_of_range& e) {
55454       {
55455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55456       };
55457     } catch (std::exception& e) {
55458       {
55459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55460       };
55461     } catch (...) {
55462       {
55463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55464       };
55465     }
55466   }
55467   jresult = (void *)result;
55468   return jresult;
55469 }
55470
55471
55472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55473   Dali::Application *arg1 = (Dali::Application *) 0 ;
55474
55475   arg1 = (Dali::Application *)jarg1;
55476   {
55477     try {
55478       delete arg1;
55479     } catch (std::out_of_range& e) {
55480       {
55481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (std::exception& e) {
55484       {
55485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55490       };
55491     }
55492   }
55493 }
55494
55495
55496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55497   Dali::Application *arg1 = (Dali::Application *) 0 ;
55498
55499   arg1 = (Dali::Application *)jarg1;
55500   {
55501     try {
55502       (arg1)->MainLoop();
55503     } catch (std::out_of_range& e) {
55504       {
55505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55506       };
55507     } catch (std::exception& e) {
55508       {
55509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55510       };
55511     } catch (...) {
55512       {
55513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55514       };
55515     }
55516   }
55517 }
55518
55519
55520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55521   Dali::Application *arg1 = (Dali::Application *) 0 ;
55522   Configuration::ContextLoss arg2 ;
55523   Configuration::ContextLoss *argp2 ;
55524
55525   arg1 = (Dali::Application *)jarg1;
55526   argp2 = (Configuration::ContextLoss *)jarg2;
55527   if (!argp2) {
55528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55529     return ;
55530   }
55531   arg2 = *argp2;
55532   {
55533     try {
55534       (arg1)->MainLoop(arg2);
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55542       };
55543     } catch (...) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55546       };
55547     }
55548   }
55549 }
55550
55551
55552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55553   Dali::Application *arg1 = (Dali::Application *) 0 ;
55554
55555   arg1 = (Dali::Application *)jarg1;
55556   {
55557     try {
55558       (arg1)->Lower();
55559     } catch (std::out_of_range& e) {
55560       {
55561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55562       };
55563     } catch (std::exception& e) {
55564       {
55565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55566       };
55567     } catch (...) {
55568       {
55569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55570       };
55571     }
55572   }
55573 }
55574
55575
55576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55577   Dali::Application *arg1 = (Dali::Application *) 0 ;
55578
55579   arg1 = (Dali::Application *)jarg1;
55580   {
55581     try {
55582       (arg1)->Quit();
55583     } catch (std::out_of_range& e) {
55584       {
55585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55586       };
55587     } catch (std::exception& e) {
55588       {
55589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55590       };
55591     } catch (...) {
55592       {
55593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55594       };
55595     }
55596   }
55597 }
55598
55599
55600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55601   unsigned int jresult ;
55602   Dali::Application *arg1 = (Dali::Application *) 0 ;
55603   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55604   bool result;
55605
55606   arg1 = (Dali::Application *)jarg1;
55607   arg2 = (Dali::CallbackBase *)jarg2;
55608   {
55609     try {
55610       result = (bool)(arg1)->AddIdle(arg2);
55611     } catch (std::out_of_range& e) {
55612       {
55613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (std::exception& e) {
55616       {
55617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55618       };
55619     } catch (...) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55622       };
55623     }
55624   }
55625   jresult = result;
55626   return jresult;
55627 }
55628
55629
55630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55631   void * jresult ;
55632   Dali::Application *arg1 = (Dali::Application *) 0 ;
55633   Dali::Window result;
55634
55635   arg1 = (Dali::Application *)jarg1;
55636   {
55637     try {
55638       result = (arg1)->GetWindow();
55639     } catch (std::out_of_range& e) {
55640       {
55641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55642       };
55643     } catch (std::exception& e) {
55644       {
55645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55646       };
55647     } catch (...) {
55648       {
55649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55650       };
55651     }
55652   }
55653   jresult = new Dali::Window((const Dali::Window &)result);
55654   return jresult;
55655 }
55656
55657
55658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55659   Dali::Application *arg1 = (Dali::Application *) 0 ;
55660   Dali::PositionSize arg2 ;
55661   std::string *arg3 = 0 ;
55662   Dali::PositionSize *argp2 ;
55663
55664   arg1 = (Dali::Application *)jarg1;
55665   argp2 = (Dali::PositionSize *)jarg2;
55666   if (!argp2) {
55667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55668     return ;
55669   }
55670   arg2 = *argp2;
55671   if (!jarg3) {
55672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55673     return ;
55674   }
55675   std::string arg3_str(jarg3);
55676   arg3 = &arg3_str;
55677   {
55678     try {
55679       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55680     } catch (std::out_of_range& e) {
55681       {
55682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55683       };
55684     } catch (std::exception& e) {
55685       {
55686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55687       };
55688     } catch (...) {
55689       {
55690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55691       };
55692     }
55693   }
55694
55695   //argout typemap for const std::string&
55696
55697 }
55698
55699
55700 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55701   char * jresult ;
55702   std::string result;
55703
55704   {
55705     try {
55706       result = Dali::Application::GetResourcePath();
55707     } catch (std::out_of_range& e) {
55708       {
55709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55710       };
55711     } catch (std::exception& e) {
55712       {
55713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55714       };
55715     } catch (...) {
55716       {
55717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55718       };
55719     }
55720   }
55721   jresult = SWIG_csharp_string_callback((&result)->c_str());
55722   return jresult;
55723 }
55724
55725
55726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55727   Dali::Application *arg1 = (Dali::Application *) 0 ;
55728   Dali::ViewMode arg2 ;
55729
55730   arg1 = (Dali::Application *)jarg1;
55731   arg2 = (Dali::ViewMode)jarg2;
55732   {
55733     try {
55734       (arg1)->SetViewMode(arg2);
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55742       };
55743     } catch (...) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55746       };
55747     }
55748   }
55749 }
55750
55751
55752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55753   int jresult ;
55754   Dali::Application *arg1 = (Dali::Application *) 0 ;
55755   Dali::ViewMode result;
55756
55757   arg1 = (Dali::Application *)jarg1;
55758   {
55759     try {
55760       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55761     } catch (std::out_of_range& e) {
55762       {
55763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55764       };
55765     } catch (std::exception& e) {
55766       {
55767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55768       };
55769     } catch (...) {
55770       {
55771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55772       };
55773     }
55774   }
55775   jresult = (int)result;
55776   return jresult;
55777 }
55778
55779
55780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55781   Dali::Application *arg1 = (Dali::Application *) 0 ;
55782   float arg2 ;
55783
55784   arg1 = (Dali::Application *)jarg1;
55785   arg2 = (float)jarg2;
55786   {
55787     try {
55788       (arg1)->SetStereoBase(arg2);
55789     } catch (std::out_of_range& e) {
55790       {
55791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55792       };
55793     } catch (std::exception& e) {
55794       {
55795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55800       };
55801     }
55802   }
55803 }
55804
55805
55806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55807   float jresult ;
55808   Dali::Application *arg1 = (Dali::Application *) 0 ;
55809   float result;
55810
55811   arg1 = (Dali::Application *)jarg1;
55812   {
55813     try {
55814       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55815     } catch (std::out_of_range& e) {
55816       {
55817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55818       };
55819     } catch (std::exception& e) {
55820       {
55821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55826       };
55827     }
55828   }
55829   jresult = result;
55830   return jresult;
55831 }
55832
55833
55834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55835   void * jresult ;
55836   Dali::Application *arg1 = (Dali::Application *) 0 ;
55837   Dali::Application::AppSignalType *result = 0 ;
55838
55839   arg1 = (Dali::Application *)jarg1;
55840   {
55841     try {
55842       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55843     } catch (std::out_of_range& e) {
55844       {
55845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55846       };
55847     } catch (std::exception& e) {
55848       {
55849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55850       };
55851     } catch (...) {
55852       {
55853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55854       };
55855     }
55856   }
55857   jresult = (void *)result;
55858   return jresult;
55859 }
55860
55861
55862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55863   void * jresult ;
55864   Dali::Application *arg1 = (Dali::Application *) 0 ;
55865   Dali::Application::AppSignalType *result = 0 ;
55866
55867   arg1 = (Dali::Application *)jarg1;
55868   {
55869     try {
55870       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55871     } catch (std::out_of_range& e) {
55872       {
55873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55874       };
55875     } catch (std::exception& e) {
55876       {
55877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55878       };
55879     } catch (...) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55882       };
55883     }
55884   }
55885   jresult = (void *)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55891   void * jresult ;
55892   Dali::Application *arg1 = (Dali::Application *) 0 ;
55893   Dali::Application::AppSignalType *result = 0 ;
55894
55895   arg1 = (Dali::Application *)jarg1;
55896   {
55897     try {
55898       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55906       };
55907     } catch (...) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55910       };
55911     }
55912   }
55913   jresult = (void *)result;
55914   return jresult;
55915 }
55916
55917
55918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55919   void * jresult ;
55920   Dali::Application *arg1 = (Dali::Application *) 0 ;
55921   Dali::Application::AppSignalType *result = 0 ;
55922
55923   arg1 = (Dali::Application *)jarg1;
55924   {
55925     try {
55926       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55927     } catch (std::out_of_range& e) {
55928       {
55929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55930       };
55931     } catch (std::exception& e) {
55932       {
55933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55934       };
55935     } catch (...) {
55936       {
55937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55938       };
55939     }
55940   }
55941   jresult = (void *)result;
55942   return jresult;
55943 }
55944
55945
55946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55947   void * jresult ;
55948   Dali::Application *arg1 = (Dali::Application *) 0 ;
55949   Dali::Application::AppSignalType *result = 0 ;
55950
55951   arg1 = (Dali::Application *)jarg1;
55952   {
55953     try {
55954       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55955     } catch (std::out_of_range& e) {
55956       {
55957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55958       };
55959     } catch (std::exception& e) {
55960       {
55961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55962       };
55963     } catch (...) {
55964       {
55965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55966       };
55967     }
55968   }
55969   jresult = (void *)result;
55970   return jresult;
55971 }
55972
55973
55974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55975   void * jresult ;
55976   Dali::Application *arg1 = (Dali::Application *) 0 ;
55977   Dali::Application::AppSignalType *result = 0 ;
55978
55979   arg1 = (Dali::Application *)jarg1;
55980   {
55981     try {
55982       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55983     } catch (std::out_of_range& e) {
55984       {
55985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55986       };
55987     } catch (std::exception& e) {
55988       {
55989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55990       };
55991     } catch (...) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55994       };
55995     }
55996   }
55997   jresult = (void *)result;
55998   return jresult;
55999 }
56000
56001
56002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
56003   void * jresult ;
56004   Dali::Application *arg1 = (Dali::Application *) 0 ;
56005   Dali::Application::AppControlSignalType *result = 0 ;
56006
56007   arg1 = (Dali::Application *)jarg1;
56008   {
56009     try {
56010       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
56011     } catch (std::out_of_range& e) {
56012       {
56013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56014       };
56015     } catch (std::exception& e) {
56016       {
56017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (...) {
56020       {
56021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56022       };
56023     }
56024   }
56025   jresult = (void *)result;
56026   return jresult;
56027 }
56028
56029
56030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
56031   void * jresult ;
56032   Dali::Application *arg1 = (Dali::Application *) 0 ;
56033   Dali::Application::AppSignalType *result = 0 ;
56034
56035   arg1 = (Dali::Application *)jarg1;
56036   {
56037     try {
56038       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56039     } catch (std::out_of_range& e) {
56040       {
56041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56042       };
56043     } catch (std::exception& e) {
56044       {
56045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56046       };
56047     } catch (...) {
56048       {
56049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56050       };
56051     }
56052   }
56053   jresult = (void *)result;
56054   return jresult;
56055 }
56056
56057
56058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
56059   void * jresult ;
56060   Dali::Application *arg1 = (Dali::Application *) 0 ;
56061   Dali::Application::AppSignalType *result = 0 ;
56062
56063   arg1 = (Dali::Application *)jarg1;
56064   {
56065     try {
56066       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56067     } catch (std::out_of_range& e) {
56068       {
56069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56070       };
56071     } catch (std::exception& e) {
56072       {
56073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (...) {
56076       {
56077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56078       };
56079     }
56080   }
56081   jresult = (void *)result;
56082   return jresult;
56083 }
56084
56085
56086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
56087   void * jresult ;
56088   Dali::Application *arg1 = (Dali::Application *) 0 ;
56089   Dali::Application::AppSignalType *result = 0 ;
56090
56091   arg1 = (Dali::Application *)jarg1;
56092   {
56093     try {
56094       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56095     } catch (std::out_of_range& e) {
56096       {
56097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56098       };
56099     } catch (std::exception& e) {
56100       {
56101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56102       };
56103     } catch (...) {
56104       {
56105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56106       };
56107     }
56108   }
56109   jresult = (void *)result;
56110   return jresult;
56111 }
56112
56113
56114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56115   void * jresult ;
56116   Dali::Application *arg1 = (Dali::Application *) 0 ;
56117   Dali::Application::AppSignalType *result = 0 ;
56118
56119   arg1 = (Dali::Application *)jarg1;
56120   {
56121     try {
56122       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56123     } catch (std::out_of_range& e) {
56124       {
56125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56126       };
56127     } catch (std::exception& e) {
56128       {
56129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (...) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56134       };
56135     }
56136   }
56137   jresult = (void *)result;
56138   return jresult;
56139 }
56140
56141
56142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56143   unsigned int jresult ;
56144   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56145   bool result;
56146
56147   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56148   {
56149     try {
56150       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56151     } catch (std::out_of_range& e) {
56152       {
56153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56154       };
56155     } catch (std::exception& e) {
56156       {
56157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56158       };
56159     } catch (...) {
56160       {
56161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56162       };
56163     }
56164   }
56165   jresult = result;
56166   return jresult;
56167 }
56168
56169
56170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56171   unsigned long jresult ;
56172   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56173   std::size_t result;
56174
56175   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56176   {
56177     try {
56178       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56179     } catch (std::out_of_range& e) {
56180       {
56181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56182       };
56183     } catch (std::exception& e) {
56184       {
56185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56186       };
56187     } catch (...) {
56188       {
56189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56190       };
56191     }
56192   }
56193   jresult = (unsigned long)result;
56194   return jresult;
56195 }
56196
56197
56198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56199   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56200   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56201
56202   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56203   arg2 = (void (*)(Dali::Application &))jarg2;
56204   {
56205     try {
56206       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56207     } catch (std::out_of_range& e) {
56208       {
56209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56210       };
56211     } catch (std::exception& e) {
56212       {
56213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (...) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56218       };
56219     }
56220   }
56221 }
56222
56223
56224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56225   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56226   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56227
56228   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56229   arg2 = (void (*)(Dali::Application &))jarg2;
56230   {
56231     try {
56232       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56233     } catch (std::out_of_range& e) {
56234       {
56235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56236       };
56237     } catch (std::exception& e) {
56238       {
56239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56240       };
56241     } catch (...) {
56242       {
56243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56244       };
56245     }
56246   }
56247 }
56248
56249
56250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56251   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56252   Dali::Application *arg2 = 0 ;
56253
56254   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56255   arg2 = (Dali::Application *)jarg2;
56256   if (!arg2) {
56257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56258     return ;
56259   }
56260   {
56261     try {
56262       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (...) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56274       };
56275     }
56276   }
56277 }
56278
56279
56280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56281   void * jresult ;
56282   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56283
56284   {
56285     try {
56286       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56287     } catch (std::out_of_range& e) {
56288       {
56289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (std::exception& e) {
56292       {
56293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (...) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56298       };
56299     }
56300   }
56301   jresult = (void *)result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56307   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56308
56309   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56310   {
56311     try {
56312       delete arg1;
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56320       };
56321     } catch (...) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56324       };
56325     }
56326   }
56327 }
56328
56329
56330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56331   unsigned int jresult ;
56332   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56333   bool result;
56334
56335   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56336   {
56337     try {
56338       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56339     } catch (std::out_of_range& e) {
56340       {
56341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (std::exception& e) {
56344       {
56345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56350       };
56351     }
56352   }
56353   jresult = result;
56354   return jresult;
56355 }
56356
56357
56358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56359   unsigned long jresult ;
56360   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56361   std::size_t result;
56362
56363   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56364   {
56365     try {
56366       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56374       };
56375     } catch (...) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56378       };
56379     }
56380   }
56381   jresult = (unsigned long)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56387   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56388   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56389
56390   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56391   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56392   {
56393     try {
56394       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (...) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56406       };
56407     }
56408   }
56409 }
56410
56411
56412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56413   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56414   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56415
56416   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56417   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56418   {
56419     try {
56420       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56421     } catch (std::out_of_range& e) {
56422       {
56423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56424       };
56425     } catch (std::exception& e) {
56426       {
56427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56428       };
56429     } catch (...) {
56430       {
56431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56432       };
56433     }
56434   }
56435 }
56436
56437
56438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56439   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56440   Dali::Application *arg2 = 0 ;
56441   void *arg3 = (void *) 0 ;
56442
56443   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56444   arg2 = (Dali::Application *)jarg2;
56445   if (!arg2) {
56446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56447     return ;
56448   }
56449   arg3 = jarg3;
56450   {
56451     try {
56452       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56460       };
56461     } catch (...) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56464       };
56465     }
56466   }
56467 }
56468
56469
56470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56471   void * jresult ;
56472   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56473
56474   {
56475     try {
56476       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56477     } catch (std::out_of_range& e) {
56478       {
56479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56480       };
56481     } catch (std::exception& e) {
56482       {
56483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56484       };
56485     } catch (...) {
56486       {
56487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56488       };
56489     }
56490   }
56491   jresult = (void *)result;
56492   return jresult;
56493 }
56494
56495
56496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56497   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56498
56499   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56500   {
56501     try {
56502       delete arg1;
56503     } catch (std::out_of_range& e) {
56504       {
56505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56506       };
56507     } catch (std::exception& e) {
56508       {
56509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56510       };
56511     } catch (...) {
56512       {
56513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56514       };
56515     }
56516   }
56517 }
56518
56519
56520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56521   unsigned int jresult ;
56522   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56523   bool result;
56524
56525   arg1 = (Dali::Signal< bool () > *)jarg1;
56526   {
56527     try {
56528       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56529     } catch (std::out_of_range& e) {
56530       {
56531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56532       };
56533     } catch (std::exception& e) {
56534       {
56535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56536       };
56537     } catch (...) {
56538       {
56539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56540       };
56541     }
56542   }
56543   jresult = result;
56544   return jresult;
56545 }
56546
56547
56548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56549   unsigned long jresult ;
56550   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56551   std::size_t result;
56552
56553   arg1 = (Dali::Signal< bool () > *)jarg1;
56554   {
56555     try {
56556       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56557     } catch (std::out_of_range& e) {
56558       {
56559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56560       };
56561     } catch (std::exception& e) {
56562       {
56563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (...) {
56566       {
56567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56568       };
56569     }
56570   }
56571   jresult = (unsigned long)result;
56572   return jresult;
56573 }
56574
56575
56576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56577   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56578   bool (*arg2)() = (bool (*)()) 0 ;
56579
56580   arg1 = (Dali::Signal< bool () > *)jarg1;
56581   arg2 = (bool (*)())jarg2;
56582   {
56583     try {
56584       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56592       };
56593     } catch (...) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56596       };
56597     }
56598   }
56599 }
56600
56601
56602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56603   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56604   bool (*arg2)() = (bool (*)()) 0 ;
56605
56606   arg1 = (Dali::Signal< bool () > *)jarg1;
56607   arg2 = (bool (*)())jarg2;
56608   {
56609     try {
56610       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56611     } catch (std::out_of_range& e) {
56612       {
56613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (std::exception& e) {
56616       {
56617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56618       };
56619     } catch (...) {
56620       {
56621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56622       };
56623     }
56624   }
56625 }
56626
56627
56628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56629   unsigned int jresult ;
56630   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56631   bool result;
56632
56633   arg1 = (Dali::Signal< bool () > *)jarg1;
56634   {
56635     try {
56636       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56637     } catch (std::out_of_range& e) {
56638       {
56639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (std::exception& e) {
56642       {
56643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (...) {
56646       {
56647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56648       };
56649     }
56650   }
56651   jresult = result;
56652   return jresult;
56653 }
56654
56655
56656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56657   void * jresult ;
56658   Dali::Signal< bool () > *result = 0 ;
56659
56660   {
56661     try {
56662       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56663     } catch (std::out_of_range& e) {
56664       {
56665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56666       };
56667     } catch (std::exception& e) {
56668       {
56669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56670       };
56671     } catch (...) {
56672       {
56673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56674       };
56675     }
56676   }
56677   jresult = (void *)result;
56678   return jresult;
56679 }
56680
56681
56682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56683   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56684
56685   arg1 = (Dali::Signal< bool () > *)jarg1;
56686   {
56687     try {
56688       delete arg1;
56689     } catch (std::out_of_range& e) {
56690       {
56691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56692       };
56693     } catch (std::exception& e) {
56694       {
56695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56696       };
56697     } catch (...) {
56698       {
56699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56700       };
56701     }
56702   }
56703 }
56704
56705
56706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56707   unsigned int jresult ;
56708   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56709   bool result;
56710
56711   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56712   {
56713     try {
56714       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56715     } catch (std::out_of_range& e) {
56716       {
56717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56718       };
56719     } catch (std::exception& e) {
56720       {
56721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56722       };
56723     } catch (...) {
56724       {
56725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56726       };
56727     }
56728   }
56729   jresult = result;
56730   return jresult;
56731 }
56732
56733
56734 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56735   unsigned long jresult ;
56736   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56737   std::size_t result;
56738
56739   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56740   {
56741     try {
56742       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56743     } catch (std::out_of_range& e) {
56744       {
56745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (std::exception& e) {
56748       {
56749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757   jresult = (unsigned long)result;
56758   return jresult;
56759 }
56760
56761
56762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56763   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56764   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56765
56766   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56767   arg2 = (void (*)(bool))jarg2;
56768   {
56769     try {
56770       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56782       };
56783     }
56784   }
56785 }
56786
56787
56788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56789   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56790   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56791
56792   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56793   arg2 = (void (*)(bool))jarg2;
56794   {
56795     try {
56796       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56797     } catch (std::out_of_range& e) {
56798       {
56799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56800       };
56801     } catch (std::exception& e) {
56802       {
56803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56804       };
56805     } catch (...) {
56806       {
56807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56808       };
56809     }
56810   }
56811 }
56812
56813
56814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56815   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56816   bool arg2 ;
56817
56818   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56819   arg2 = jarg2 ? true : false;
56820   {
56821     try {
56822       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56823     } catch (std::out_of_range& e) {
56824       {
56825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56826       };
56827     } catch (std::exception& e) {
56828       {
56829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56830       };
56831     } catch (...) {
56832       {
56833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56834       };
56835     }
56836   }
56837 }
56838
56839
56840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56841   void * jresult ;
56842   Dali::Signal< void (bool) > *result = 0 ;
56843
56844   {
56845     try {
56846       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56847     } catch (std::out_of_range& e) {
56848       {
56849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56850       };
56851     } catch (std::exception& e) {
56852       {
56853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (...) {
56856       {
56857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56858       };
56859     }
56860   }
56861   jresult = (void *)result;
56862   return jresult;
56863 }
56864
56865
56866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56867   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56868
56869   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56870   {
56871     try {
56872       delete arg1;
56873     } catch (std::out_of_range& e) {
56874       {
56875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56876       };
56877     } catch (std::exception& e) {
56878       {
56879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56880       };
56881     } catch (...) {
56882       {
56883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56884       };
56885     }
56886   }
56887 }
56888
56889
56890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56891   int jresult ;
56892   int result;
56893
56894   {
56895     try {
56896       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56897     } catch (std::out_of_range& e) {
56898       {
56899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56900       };
56901     } catch (std::exception& e) {
56902       {
56903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56904       };
56905     } catch (...) {
56906       {
56907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56908       };
56909     }
56910   }
56911   jresult = (int)result;
56912   return jresult;
56913 }
56914
56915
56916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56917   int jresult ;
56918   int result;
56919
56920   {
56921     try {
56922       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56923     } catch (std::out_of_range& e) {
56924       {
56925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56926       };
56927     } catch (std::exception& e) {
56928       {
56929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (...) {
56932       {
56933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56934       };
56935     }
56936   }
56937   jresult = (int)result;
56938   return jresult;
56939 }
56940
56941
56942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56943   int jresult ;
56944   int result;
56945
56946   {
56947     try {
56948       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56949     } catch (std::out_of_range& e) {
56950       {
56951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56952       };
56953     } catch (std::exception& e) {
56954       {
56955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (...) {
56958       {
56959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56960       };
56961     }
56962   }
56963   jresult = (int)result;
56964   return jresult;
56965 }
56966
56967
56968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56969   int jresult ;
56970   int result;
56971
56972   {
56973     try {
56974       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56975     } catch (std::out_of_range& e) {
56976       {
56977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56978       };
56979     } catch (std::exception& e) {
56980       {
56981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (...) {
56984       {
56985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56986       };
56987     }
56988   }
56989   jresult = (int)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56995   int jresult ;
56996   int result;
56997
56998   {
56999     try {
57000       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (...) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57012       };
57013     }
57014   }
57015   jresult = (int)result;
57016   return jresult;
57017 }
57018
57019
57020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
57021   int jresult ;
57022   int result;
57023
57024   {
57025     try {
57026       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57038       };
57039     }
57040   }
57041   jresult = (int)result;
57042   return jresult;
57043 }
57044
57045
57046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57047   int jresult ;
57048   int result;
57049
57050   {
57051     try {
57052       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57053     } catch (std::out_of_range& e) {
57054       {
57055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57056       };
57057     } catch (std::exception& e) {
57058       {
57059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57060       };
57061     } catch (...) {
57062       {
57063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57064       };
57065     }
57066   }
57067   jresult = (int)result;
57068   return jresult;
57069 }
57070
57071
57072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57073   int jresult ;
57074   int result;
57075
57076   {
57077     try {
57078       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57079     } catch (std::out_of_range& e) {
57080       {
57081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57082       };
57083     } catch (std::exception& e) {
57084       {
57085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (...) {
57088       {
57089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57090       };
57091     }
57092   }
57093   jresult = (int)result;
57094   return jresult;
57095 }
57096
57097
57098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57099   int jresult ;
57100   int result;
57101
57102   {
57103     try {
57104       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57105     } catch (std::out_of_range& e) {
57106       {
57107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57108       };
57109     } catch (std::exception& e) {
57110       {
57111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (...) {
57114       {
57115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57116       };
57117     }
57118   }
57119   jresult = (int)result;
57120   return jresult;
57121 }
57122
57123
57124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57125   int jresult ;
57126   int result;
57127
57128   {
57129     try {
57130       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57131     } catch (std::out_of_range& e) {
57132       {
57133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57134       };
57135     } catch (std::exception& e) {
57136       {
57137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (...) {
57140       {
57141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57142       };
57143     }
57144   }
57145   jresult = (int)result;
57146   return jresult;
57147 }
57148
57149
57150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57151   int jresult ;
57152   int result;
57153
57154   {
57155     try {
57156       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57157     } catch (std::out_of_range& e) {
57158       {
57159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57160       };
57161     } catch (std::exception& e) {
57162       {
57163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (...) {
57166       {
57167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57168       };
57169     }
57170   }
57171   jresult = (int)result;
57172   return jresult;
57173 }
57174
57175
57176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57177   int jresult ;
57178   int result;
57179
57180   {
57181     try {
57182       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57183     } catch (std::out_of_range& e) {
57184       {
57185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57186       };
57187     } catch (std::exception& e) {
57188       {
57189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (...) {
57192       {
57193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57194       };
57195     }
57196   }
57197   jresult = (int)result;
57198   return jresult;
57199 }
57200
57201
57202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57203   int jresult ;
57204   int result;
57205
57206   {
57207     try {
57208       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57209     } catch (std::out_of_range& e) {
57210       {
57211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (std::exception& e) {
57214       {
57215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223   jresult = (int)result;
57224   return jresult;
57225 }
57226
57227
57228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57229   int jresult ;
57230   int result;
57231
57232   {
57233     try {
57234       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57235     } catch (std::out_of_range& e) {
57236       {
57237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57238       };
57239     } catch (std::exception& e) {
57240       {
57241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57242       };
57243     } catch (...) {
57244       {
57245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57246       };
57247     }
57248   }
57249   jresult = (int)result;
57250   return jresult;
57251 }
57252
57253
57254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57255   int jresult ;
57256   int result;
57257
57258   {
57259     try {
57260       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (...) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57272       };
57273     }
57274   }
57275   jresult = (int)result;
57276   return jresult;
57277 }
57278
57279
57280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57281   int jresult ;
57282   int result;
57283
57284   {
57285     try {
57286       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57287     } catch (std::out_of_range& e) {
57288       {
57289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57290       };
57291     } catch (std::exception& e) {
57292       {
57293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57298       };
57299     }
57300   }
57301   jresult = (int)result;
57302   return jresult;
57303 }
57304
57305
57306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57307   int jresult ;
57308   int result;
57309
57310   {
57311     try {
57312       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57313     } catch (std::out_of_range& e) {
57314       {
57315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57316       };
57317     } catch (std::exception& e) {
57318       {
57319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (...) {
57322       {
57323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57324       };
57325     }
57326   }
57327   jresult = (int)result;
57328   return jresult;
57329 }
57330
57331
57332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57333   int jresult ;
57334   int result;
57335
57336   {
57337     try {
57338       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57339     } catch (std::out_of_range& e) {
57340       {
57341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57342       };
57343     } catch (std::exception& e) {
57344       {
57345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57346       };
57347     } catch (...) {
57348       {
57349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57350       };
57351     }
57352   }
57353   jresult = (int)result;
57354   return jresult;
57355 }
57356
57357
57358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57359   int jresult ;
57360   int result;
57361
57362   {
57363     try {
57364       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57365     } catch (std::out_of_range& e) {
57366       {
57367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (std::exception& e) {
57370       {
57371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (...) {
57374       {
57375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57376       };
57377     }
57378   }
57379   jresult = (int)result;
57380   return jresult;
57381 }
57382
57383
57384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57385   int jresult ;
57386   int result;
57387
57388   {
57389     try {
57390       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57391     } catch (std::out_of_range& e) {
57392       {
57393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57394       };
57395     } catch (std::exception& e) {
57396       {
57397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57398       };
57399     } catch (...) {
57400       {
57401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57402       };
57403     }
57404   }
57405   jresult = (int)result;
57406   return jresult;
57407 }
57408
57409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57410   int jresult ;
57411   int result;
57412
57413   {
57414     try {
57415       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
57416     } catch (std::out_of_range& e) {
57417       {
57418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (std::exception& e) {
57421       {
57422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430   jresult = (int)result;
57431   return jresult;
57432 }
57433
57434
57435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57436   int jresult ;
57437   int result;
57438
57439   {
57440     try {
57441       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57442     } catch (std::out_of_range& e) {
57443       {
57444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57445       };
57446     } catch (std::exception& e) {
57447       {
57448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (...) {
57451       {
57452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57453       };
57454     }
57455   }
57456   jresult = (int)result;
57457   return jresult;
57458 }
57459
57460
57461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57462   int jresult ;
57463   int result;
57464
57465   {
57466     try {
57467       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57468     } catch (std::out_of_range& e) {
57469       {
57470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57471       };
57472     } catch (std::exception& e) {
57473       {
57474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57475       };
57476     } catch (...) {
57477       {
57478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57479       };
57480     }
57481   }
57482   jresult = (int)result;
57483   return jresult;
57484 }
57485
57486
57487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57488   int jresult ;
57489   int result;
57490
57491   {
57492     try {
57493       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57505       };
57506     }
57507   }
57508   jresult = (int)result;
57509   return jresult;
57510 }
57511
57512
57513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57514   int jresult ;
57515   int result;
57516
57517   {
57518     try {
57519       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534   jresult = (int)result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57540   int jresult ;
57541   int result;
57542
57543   {
57544     try {
57545       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57546     } catch (std::out_of_range& e) {
57547       {
57548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57549       };
57550     } catch (std::exception& e) {
57551       {
57552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (...) {
57555       {
57556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57557       };
57558     }
57559   }
57560   jresult = (int)result;
57561   return jresult;
57562 }
57563
57564
57565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57566   int jresult ;
57567   int result;
57568
57569   {
57570     try {
57571       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57572     } catch (std::out_of_range& e) {
57573       {
57574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (std::exception& e) {
57577       {
57578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (...) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57583       };
57584     }
57585   }
57586   jresult = (int)result;
57587   return jresult;
57588 }
57589
57590
57591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57592   int jresult ;
57593   int result;
57594
57595   {
57596     try {
57597       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57598     } catch (std::out_of_range& e) {
57599       {
57600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (std::exception& e) {
57603       {
57604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57609       };
57610     }
57611   }
57612   jresult = (int)result;
57613   return jresult;
57614 }
57615
57616
57617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57618   int jresult ;
57619   int result;
57620
57621   {
57622     try {
57623       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57624     } catch (std::out_of_range& e) {
57625       {
57626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (std::exception& e) {
57629       {
57630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57635       };
57636     }
57637   }
57638   jresult = (int)result;
57639   return jresult;
57640 }
57641
57642
57643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57644   int jresult ;
57645   int result;
57646
57647   {
57648     try {
57649       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57650     } catch (std::out_of_range& e) {
57651       {
57652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57653       };
57654     } catch (std::exception& e) {
57655       {
57656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (...) {
57659       {
57660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57661       };
57662     }
57663   }
57664   jresult = (int)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57670   int jresult ;
57671   int result;
57672
57673   {
57674     try {
57675       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57676     } catch (std::out_of_range& e) {
57677       {
57678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57679       };
57680     } catch (std::exception& e) {
57681       {
57682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57687       };
57688     }
57689   }
57690   jresult = (int)result;
57691   return jresult;
57692 }
57693
57694
57695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57696   int jresult ;
57697   int result;
57698
57699   {
57700     try {
57701       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57702     } catch (std::out_of_range& e) {
57703       {
57704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57705       };
57706     } catch (std::exception& e) {
57707       {
57708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (...) {
57711       {
57712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57713       };
57714     }
57715   }
57716   jresult = (int)result;
57717   return jresult;
57718 }
57719
57720
57721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57722   int jresult ;
57723   int result;
57724
57725   {
57726     try {
57727       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57728     } catch (std::out_of_range& e) {
57729       {
57730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57731       };
57732     } catch (std::exception& e) {
57733       {
57734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57739       };
57740     }
57741   }
57742   jresult = (int)result;
57743   return jresult;
57744 }
57745
57746
57747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57748   int jresult ;
57749   int result;
57750
57751   {
57752     try {
57753       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57765       };
57766     }
57767   }
57768   jresult = (int)result;
57769   return jresult;
57770 }
57771
57772
57773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57774   int jresult ;
57775   int result;
57776
57777   {
57778     try {
57779       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57791       };
57792     }
57793   }
57794   jresult = (int)result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57800   int jresult ;
57801   int result;
57802
57803   {
57804     try {
57805       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57806     } catch (std::out_of_range& e) {
57807       {
57808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57809       };
57810     } catch (std::exception& e) {
57811       {
57812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57813       };
57814     } catch (...) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57817       };
57818     }
57819   }
57820   jresult = (int)result;
57821   return jresult;
57822 }
57823
57824
57825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57826   int jresult ;
57827   int result;
57828
57829   {
57830     try {
57831       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57843       };
57844     }
57845   }
57846   jresult = (int)result;
57847   return jresult;
57848 }
57849
57850
57851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57852   int jresult ;
57853   int result;
57854
57855   {
57856     try {
57857       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57858     } catch (std::out_of_range& e) {
57859       {
57860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (std::exception& e) {
57863       {
57864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57865       };
57866     } catch (...) {
57867       {
57868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57869       };
57870     }
57871   }
57872   jresult = (int)result;
57873   return jresult;
57874 }
57875
57876
57877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57878   int jresult ;
57879   int result;
57880
57881   {
57882     try {
57883       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (...) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57895       };
57896     }
57897   }
57898   jresult = (int)result;
57899   return jresult;
57900 }
57901
57902
57903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57904   int jresult ;
57905   int result;
57906
57907   {
57908     try {
57909       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57910     } catch (std::out_of_range& e) {
57911       {
57912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57913       };
57914     } catch (std::exception& e) {
57915       {
57916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (...) {
57919       {
57920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57921       };
57922     }
57923   }
57924   jresult = (int)result;
57925   return jresult;
57926 }
57927
57928
57929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57930   int jresult ;
57931   int result;
57932
57933   {
57934     try {
57935       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57936     } catch (std::out_of_range& e) {
57937       {
57938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57939       };
57940     } catch (std::exception& e) {
57941       {
57942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (...) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57947       };
57948     }
57949   }
57950   jresult = (int)result;
57951   return jresult;
57952 }
57953
57954
57955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57956   int jresult ;
57957   int result;
57958
57959   {
57960     try {
57961       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57962     } catch (std::out_of_range& e) {
57963       {
57964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (std::exception& e) {
57967       {
57968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976   jresult = (int)result;
57977   return jresult;
57978 }
57979
57980
57981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57982   int jresult ;
57983   int result;
57984
57985   {
57986     try {
57987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57999       };
58000     }
58001   }
58002   jresult = (int)result;
58003   return jresult;
58004 }
58005
58006
58007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
58008   int jresult ;
58009   int result;
58010
58011   {
58012     try {
58013       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58014     } catch (std::out_of_range& e) {
58015       {
58016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58017       };
58018     } catch (std::exception& e) {
58019       {
58020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (...) {
58023       {
58024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58025       };
58026     }
58027   }
58028   jresult = (int)result;
58029   return jresult;
58030 }
58031
58032
58033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58034   int jresult ;
58035   int result;
58036
58037   {
58038     try {
58039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58040     } catch (std::out_of_range& e) {
58041       {
58042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58043       };
58044     } catch (std::exception& e) {
58045       {
58046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58051       };
58052     }
58053   }
58054   jresult = (int)result;
58055   return jresult;
58056 }
58057
58058
58059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58060   int jresult ;
58061   int result;
58062
58063   {
58064     try {
58065       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (...) {
58075       {
58076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58077       };
58078     }
58079   }
58080   jresult = (int)result;
58081   return jresult;
58082 }
58083
58084
58085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58086   int jresult ;
58087   int result;
58088
58089   {
58090     try {
58091       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58092     } catch (std::out_of_range& e) {
58093       {
58094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58095       };
58096     } catch (std::exception& e) {
58097       {
58098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58099       };
58100     } catch (...) {
58101       {
58102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58103       };
58104     }
58105   }
58106   jresult = (int)result;
58107   return jresult;
58108 }
58109
58110
58111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58112   int jresult ;
58113   int result;
58114
58115   {
58116     try {
58117       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58118     } catch (std::out_of_range& e) {
58119       {
58120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58121       };
58122     } catch (std::exception& e) {
58123       {
58124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (...) {
58127       {
58128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58129       };
58130     }
58131   }
58132   jresult = (int)result;
58133   return jresult;
58134 }
58135
58136
58137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58138   int jresult ;
58139   int result;
58140
58141   {
58142     try {
58143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58144     } catch (std::out_of_range& e) {
58145       {
58146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58147       };
58148     } catch (std::exception& e) {
58149       {
58150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (...) {
58153       {
58154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58155       };
58156     }
58157   }
58158   jresult = (int)result;
58159   return jresult;
58160 }
58161
58162
58163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58164   int jresult ;
58165   int result;
58166
58167   {
58168     try {
58169       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184   jresult = (int)result;
58185   return jresult;
58186 }
58187
58188
58189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58190   int jresult ;
58191   int result;
58192
58193   {
58194     try {
58195       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58196     } catch (std::out_of_range& e) {
58197       {
58198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58199       };
58200     } catch (std::exception& e) {
58201       {
58202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (...) {
58205       {
58206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58207       };
58208     }
58209   }
58210   jresult = (int)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58216   int jresult ;
58217   int result;
58218
58219   {
58220     try {
58221       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236   jresult = (int)result;
58237   return jresult;
58238 }
58239
58240
58241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58242   int jresult ;
58243   int result;
58244
58245   {
58246     try {
58247       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58248     } catch (std::out_of_range& e) {
58249       {
58250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58251       };
58252     } catch (std::exception& e) {
58253       {
58254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (...) {
58257       {
58258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58259       };
58260     }
58261   }
58262   jresult = (int)result;
58263   return jresult;
58264 }
58265
58266
58267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58268   int jresult ;
58269   int result;
58270
58271   {
58272     try {
58273       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58274     } catch (std::out_of_range& e) {
58275       {
58276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58277       };
58278     } catch (std::exception& e) {
58279       {
58280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (...) {
58283       {
58284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58285       };
58286     }
58287   }
58288   jresult = (int)result;
58289   return jresult;
58290 }
58291
58292
58293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58294   int jresult ;
58295   int result;
58296
58297   {
58298     try {
58299       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58300     } catch (std::out_of_range& e) {
58301       {
58302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (std::exception& e) {
58305       {
58306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314   jresult = (int)result;
58315   return jresult;
58316 }
58317
58318
58319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58320   int jresult ;
58321   int result;
58322
58323   {
58324     try {
58325       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58326     } catch (std::out_of_range& e) {
58327       {
58328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58329       };
58330     } catch (std::exception& e) {
58331       {
58332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58337       };
58338     }
58339   }
58340   jresult = (int)result;
58341   return jresult;
58342 }
58343
58344
58345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58346   int jresult ;
58347   int result;
58348
58349   {
58350     try {
58351       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58352     } catch (std::out_of_range& e) {
58353       {
58354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58355       };
58356     } catch (std::exception& e) {
58357       {
58358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (...) {
58361       {
58362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58363       };
58364     }
58365   }
58366   jresult = (int)result;
58367   return jresult;
58368 }
58369
58370
58371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58372   int jresult ;
58373   int result;
58374
58375   {
58376     try {
58377       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58378     } catch (std::out_of_range& e) {
58379       {
58380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58381       };
58382     } catch (std::exception& e) {
58383       {
58384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58389       };
58390     }
58391   }
58392   jresult = (int)result;
58393   return jresult;
58394 }
58395
58396
58397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58398   void * jresult ;
58399   Dali::Toolkit::Builder *result = 0 ;
58400
58401   {
58402     try {
58403       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58404     } catch (std::out_of_range& e) {
58405       {
58406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58407       };
58408     } catch (std::exception& e) {
58409       {
58410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (...) {
58413       {
58414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58415       };
58416     }
58417   }
58418   jresult = (void *)result;
58419   return jresult;
58420 }
58421
58422
58423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58424   void * jresult ;
58425   Dali::Toolkit::Builder result;
58426
58427   {
58428     try {
58429       result = Dali::Toolkit::Builder::New();
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (...) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58441       };
58442     }
58443   }
58444   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58445   return jresult;
58446 }
58447
58448
58449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58451
58452   arg1 = (Dali::Toolkit::Builder *)jarg1;
58453   {
58454     try {
58455       delete arg1;
58456     } catch (std::out_of_range& e) {
58457       {
58458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58459       };
58460     } catch (std::exception& e) {
58461       {
58462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58467       };
58468     }
58469   }
58470 }
58471
58472
58473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58475   std::string *arg2 = 0 ;
58476   Dali::Toolkit::Builder::UIFormat arg3 ;
58477
58478   arg1 = (Dali::Toolkit::Builder *)jarg1;
58479   if (!jarg2) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58481     return ;
58482   }
58483   std::string arg2_str(jarg2);
58484   arg2 = &arg2_str;
58485   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58486   {
58487     try {
58488       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58489     } catch (std::out_of_range& e) {
58490       {
58491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58492       };
58493     } catch (std::exception& e) {
58494       {
58495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58500       };
58501     }
58502   }
58503
58504   //argout typemap for const std::string&
58505
58506 }
58507
58508
58509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58510   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58511   std::string *arg2 = 0 ;
58512
58513   arg1 = (Dali::Toolkit::Builder *)jarg1;
58514   if (!jarg2) {
58515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58516     return ;
58517   }
58518   std::string arg2_str(jarg2);
58519   arg2 = &arg2_str;
58520   {
58521     try {
58522       (arg1)->LoadFromString((std::string const &)*arg2);
58523     } catch (std::out_of_range& e) {
58524       {
58525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58526       };
58527     } catch (std::exception& e) {
58528       {
58529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58534       };
58535     }
58536   }
58537
58538   //argout typemap for const std::string&
58539
58540 }
58541
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58545   Dali::Property::Map *arg2 = 0 ;
58546
58547   arg1 = (Dali::Toolkit::Builder *)jarg1;
58548   arg2 = (Dali::Property::Map *)jarg2;
58549   if (!arg2) {
58550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58551     return ;
58552   }
58553   {
58554     try {
58555       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58556     } catch (std::out_of_range& e) {
58557       {
58558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58559       };
58560     } catch (std::exception& e) {
58561       {
58562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58567       };
58568     }
58569   }
58570 }
58571
58572
58573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58574   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58575   std::string *arg2 = 0 ;
58576   Dali::Property::Value *arg3 = 0 ;
58577
58578   arg1 = (Dali::Toolkit::Builder *)jarg1;
58579   if (!jarg2) {
58580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58581     return ;
58582   }
58583   std::string arg2_str(jarg2);
58584   arg2 = &arg2_str;
58585   arg3 = (Dali::Property::Value *)jarg3;
58586   if (!arg3) {
58587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58588     return ;
58589   }
58590   {
58591     try {
58592       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (...) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58604       };
58605     }
58606   }
58607
58608   //argout typemap for const std::string&
58609
58610 }
58611
58612
58613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58614   void * jresult ;
58615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58616   Dali::Property::Map *result = 0 ;
58617
58618   arg1 = (Dali::Toolkit::Builder *)jarg1;
58619   {
58620     try {
58621       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58622     } catch (std::out_of_range& e) {
58623       {
58624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58625       };
58626     } catch (std::exception& e) {
58627       {
58628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (...) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58633       };
58634     }
58635   }
58636   jresult = (void *)result;
58637   return jresult;
58638 }
58639
58640
58641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58642   void * jresult ;
58643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58644   std::string *arg2 = 0 ;
58645   Dali::Property::Value *result = 0 ;
58646
58647   arg1 = (Dali::Toolkit::Builder *)jarg1;
58648   if (!jarg2) {
58649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58650     return 0;
58651   }
58652   std::string arg2_str(jarg2);
58653   arg2 = &arg2_str;
58654   {
58655     try {
58656       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58668       };
58669     }
58670   }
58671   jresult = (void *)result;
58672
58673   //argout typemap for const std::string&
58674
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58680   void * jresult ;
58681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58682   std::string *arg2 = 0 ;
58683   Dali::Animation result;
58684
58685   arg1 = (Dali::Toolkit::Builder *)jarg1;
58686   if (!jarg2) {
58687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58688     return 0;
58689   }
58690   std::string arg2_str(jarg2);
58691   arg2 = &arg2_str;
58692   {
58693     try {
58694       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709   jresult = new Dali::Animation((const Dali::Animation &)result);
58710
58711   //argout typemap for const std::string&
58712
58713   return jresult;
58714 }
58715
58716
58717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58718   void * jresult ;
58719   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58720   std::string *arg2 = 0 ;
58721   Dali::Property::Map *arg3 = 0 ;
58722   Dali::Animation result;
58723
58724   arg1 = (Dali::Toolkit::Builder *)jarg1;
58725   if (!jarg2) {
58726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58727     return 0;
58728   }
58729   std::string arg2_str(jarg2);
58730   arg2 = &arg2_str;
58731   arg3 = (Dali::Property::Map *)jarg3;
58732   if (!arg3) {
58733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58734     return 0;
58735   }
58736   {
58737     try {
58738       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (...) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58750       };
58751     }
58752   }
58753   jresult = new Dali::Animation((const Dali::Animation &)result);
58754
58755   //argout typemap for const std::string&
58756
58757   return jresult;
58758 }
58759
58760
58761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58762   void * jresult ;
58763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58764   std::string *arg2 = 0 ;
58765   Dali::Actor arg3 ;
58766   Dali::Actor *argp3 ;
58767   Dali::Animation result;
58768
58769   arg1 = (Dali::Toolkit::Builder *)jarg1;
58770   if (!jarg2) {
58771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58772     return 0;
58773   }
58774   std::string arg2_str(jarg2);
58775   arg2 = &arg2_str;
58776   argp3 = (Dali::Actor *)jarg3;
58777   if (!argp3) {
58778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58779     return 0;
58780   }
58781   arg3 = *argp3;
58782   {
58783     try {
58784       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58785     } catch (std::out_of_range& e) {
58786       {
58787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58788       };
58789     } catch (std::exception& e) {
58790       {
58791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58792       };
58793     } catch (...) {
58794       {
58795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58796       };
58797     }
58798   }
58799   jresult = new Dali::Animation((const Dali::Animation &)result);
58800
58801   //argout typemap for const std::string&
58802
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58808   void * jresult ;
58809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58810   std::string *arg2 = 0 ;
58811   Dali::Property::Map *arg3 = 0 ;
58812   Dali::Actor arg4 ;
58813   Dali::Actor *argp4 ;
58814   Dali::Animation result;
58815
58816   arg1 = (Dali::Toolkit::Builder *)jarg1;
58817   if (!jarg2) {
58818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58819     return 0;
58820   }
58821   std::string arg2_str(jarg2);
58822   arg2 = &arg2_str;
58823   arg3 = (Dali::Property::Map *)jarg3;
58824   if (!arg3) {
58825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58826     return 0;
58827   }
58828   argp4 = (Dali::Actor *)jarg4;
58829   if (!argp4) {
58830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58831     return 0;
58832   }
58833   arg4 = *argp4;
58834   {
58835     try {
58836       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (...) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58848       };
58849     }
58850   }
58851   jresult = new Dali::Animation((const Dali::Animation &)result);
58852
58853   //argout typemap for const std::string&
58854
58855   return jresult;
58856 }
58857
58858
58859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58860   void * jresult ;
58861   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58862   std::string *arg2 = 0 ;
58863   Dali::BaseHandle result;
58864
58865   arg1 = (Dali::Toolkit::Builder *)jarg1;
58866   if (!jarg2) {
58867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58868     return 0;
58869   }
58870   std::string arg2_str(jarg2);
58871   arg2 = &arg2_str;
58872   {
58873     try {
58874       result = (arg1)->Create((std::string const &)*arg2);
58875     } catch (std::out_of_range& e) {
58876       {
58877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58878       };
58879     } catch (std::exception& e) {
58880       {
58881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58886       };
58887     }
58888   }
58889   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58890
58891   //argout typemap for const std::string&
58892
58893   return jresult;
58894 }
58895
58896
58897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58898   void * jresult ;
58899   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58900   std::string *arg2 = 0 ;
58901   Dali::Property::Map *arg3 = 0 ;
58902   Dali::BaseHandle result;
58903
58904   arg1 = (Dali::Toolkit::Builder *)jarg1;
58905   if (!jarg2) {
58906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58907     return 0;
58908   }
58909   std::string arg2_str(jarg2);
58910   arg2 = &arg2_str;
58911   arg3 = (Dali::Property::Map *)jarg3;
58912   if (!arg3) {
58913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58914     return 0;
58915   }
58916   {
58917     try {
58918       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (...) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58930       };
58931     }
58932   }
58933   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58934
58935   //argout typemap for const std::string&
58936
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58942   void * jresult ;
58943   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58944   std::string *arg2 = 0 ;
58945   Dali::BaseHandle result;
58946
58947   arg1 = (Dali::Toolkit::Builder *)jarg1;
58948   if (!jarg2) {
58949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58950     return 0;
58951   }
58952   std::string arg2_str(jarg2);
58953   arg2 = &arg2_str;
58954   {
58955     try {
58956       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58957     } catch (std::out_of_range& e) {
58958       {
58959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (std::exception& e) {
58962       {
58963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58972
58973   //argout typemap for const std::string&
58974
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58980   unsigned int jresult ;
58981   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58982   std::string *arg2 = 0 ;
58983   Dali::Handle *arg3 = 0 ;
58984   bool result;
58985
58986   arg1 = (Dali::Toolkit::Builder *)jarg1;
58987   if (!jarg2) {
58988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58989     return 0;
58990   }
58991   std::string arg2_str(jarg2);
58992   arg2 = &arg2_str;
58993   arg3 = (Dali::Handle *)jarg3;
58994   if (!arg3) {
58995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58996     return 0;
58997   }
58998   {
58999     try {
59000       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
59001     } catch (std::out_of_range& e) {
59002       {
59003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59004       };
59005     } catch (std::exception& e) {
59006       {
59007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (...) {
59010       {
59011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59012       };
59013     }
59014   }
59015   jresult = result;
59016
59017   //argout typemap for const std::string&
59018
59019   return jresult;
59020 }
59021
59022
59023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59024   unsigned int jresult ;
59025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59026   Dali::Handle *arg2 = 0 ;
59027   std::string *arg3 = 0 ;
59028   bool result;
59029
59030   arg1 = (Dali::Toolkit::Builder *)jarg1;
59031   arg2 = (Dali::Handle *)jarg2;
59032   if (!arg2) {
59033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59034     return 0;
59035   }
59036   if (!jarg3) {
59037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59038     return 0;
59039   }
59040   std::string arg3_str(jarg3);
59041   arg3 = &arg3_str;
59042   {
59043     try {
59044       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59045     } catch (std::out_of_range& e) {
59046       {
59047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (std::exception& e) {
59050       {
59051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (...) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59056       };
59057     }
59058   }
59059   jresult = result;
59060
59061   //argout typemap for const std::string&
59062
59063   return jresult;
59064 }
59065
59066
59067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59068   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59069   Dali::Actor arg2 ;
59070   Dali::Actor *argp2 ;
59071
59072   arg1 = (Dali::Toolkit::Builder *)jarg1;
59073   argp2 = (Dali::Actor *)jarg2;
59074   if (!argp2) {
59075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59076     return ;
59077   }
59078   arg2 = *argp2;
59079   {
59080     try {
59081       (arg1)->AddActors(arg2);
59082     } catch (std::out_of_range& e) {
59083       {
59084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (std::exception& e) {
59087       {
59088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096 }
59097
59098
59099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59101   std::string *arg2 = 0 ;
59102   Dali::Actor arg3 ;
59103   Dali::Actor *argp3 ;
59104
59105   arg1 = (Dali::Toolkit::Builder *)jarg1;
59106   if (!jarg2) {
59107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59108     return ;
59109   }
59110   std::string arg2_str(jarg2);
59111   arg2 = &arg2_str;
59112   argp3 = (Dali::Actor *)jarg3;
59113   if (!argp3) {
59114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59115     return ;
59116   }
59117   arg3 = *argp3;
59118   {
59119     try {
59120       (arg1)->AddActors((std::string const &)*arg2,arg3);
59121     } catch (std::out_of_range& e) {
59122       {
59123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59124       };
59125     } catch (std::exception& e) {
59126       {
59127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (...) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59132       };
59133     }
59134   }
59135
59136   //argout typemap for const std::string&
59137
59138 }
59139
59140
59141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59142   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59143   std::string *arg2 = 0 ;
59144
59145   arg1 = (Dali::Toolkit::Builder *)jarg1;
59146   if (!jarg2) {
59147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59148     return ;
59149   }
59150   std::string arg2_str(jarg2);
59151   arg2 = &arg2_str;
59152   {
59153     try {
59154       (arg1)->CreateRenderTask((std::string const &)*arg2);
59155     } catch (std::out_of_range& e) {
59156       {
59157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59158       };
59159     } catch (std::exception& e) {
59160       {
59161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59162       };
59163     } catch (...) {
59164       {
59165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59166       };
59167     }
59168   }
59169
59170   //argout typemap for const std::string&
59171
59172 }
59173
59174
59175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59176   void * jresult ;
59177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59178   std::string *arg2 = 0 ;
59179   Dali::FrameBufferImage result;
59180
59181   arg1 = (Dali::Toolkit::Builder *)jarg1;
59182   if (!jarg2) {
59183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59184     return 0;
59185   }
59186   std::string arg2_str(jarg2);
59187   arg2 = &arg2_str;
59188   {
59189     try {
59190       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59191     } catch (std::out_of_range& e) {
59192       {
59193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59194       };
59195     } catch (std::exception& e) {
59196       {
59197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59202       };
59203     }
59204   }
59205   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59206
59207   //argout typemap for const std::string&
59208
59209   return jresult;
59210 }
59211
59212
59213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59214   void * jresult ;
59215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59216   std::string *arg2 = 0 ;
59217   Dali::Path result;
59218
59219   arg1 = (Dali::Toolkit::Builder *)jarg1;
59220   if (!jarg2) {
59221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59222     return 0;
59223   }
59224   std::string arg2_str(jarg2);
59225   arg2 = &arg2_str;
59226   {
59227     try {
59228       result = (arg1)->GetPath((std::string const &)*arg2);
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59240       };
59241     }
59242   }
59243   jresult = new Dali::Path((const Dali::Path &)result);
59244
59245   //argout typemap for const std::string&
59246
59247   return jresult;
59248 }
59249
59250
59251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59252   void * jresult ;
59253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59254   std::string *arg2 = 0 ;
59255   Dali::PathConstrainer result;
59256
59257   arg1 = (Dali::Toolkit::Builder *)jarg1;
59258   if (!jarg2) {
59259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59260     return 0;
59261   }
59262   std::string arg2_str(jarg2);
59263   arg2 = &arg2_str;
59264   {
59265     try {
59266       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (...) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59278       };
59279     }
59280   }
59281   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59282
59283   //argout typemap for const std::string&
59284
59285   return jresult;
59286 }
59287
59288
59289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59290   void * jresult ;
59291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59292   std::string *arg2 = 0 ;
59293   Dali::LinearConstrainer result;
59294
59295   arg1 = (Dali::Toolkit::Builder *)jarg1;
59296   if (!jarg2) {
59297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59298     return 0;
59299   }
59300   std::string arg2_str(jarg2);
59301   arg2 = &arg2_str;
59302   {
59303     try {
59304       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59305     } catch (std::out_of_range& e) {
59306       {
59307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59308       };
59309     } catch (std::exception& e) {
59310       {
59311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (...) {
59314       {
59315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59316       };
59317     }
59318   }
59319   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59320
59321   //argout typemap for const std::string&
59322
59323   return jresult;
59324 }
59325
59326
59327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59328   void * jresult ;
59329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59330   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59331
59332   arg1 = (Dali::Toolkit::Builder *)jarg1;
59333   {
59334     try {
59335       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59336     } catch (std::out_of_range& e) {
59337       {
59338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (std::exception& e) {
59341       {
59342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (...) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59347       };
59348     }
59349   }
59350   jresult = (void *)result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59356   void * jresult ;
59357   Dali::Toolkit::TransitionData *result = 0 ;
59358
59359   {
59360     try {
59361       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59373       };
59374     }
59375   }
59376   jresult = (void *)result;
59377   return jresult;
59378 }
59379
59380
59381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59382   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59383
59384   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59385   {
59386     try {
59387       delete arg1;
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402 }
59403
59404
59405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59406   void * jresult ;
59407   Dali::Property::Map *arg1 = 0 ;
59408   Dali::Toolkit::TransitionData result;
59409
59410   arg1 = (Dali::Property::Map *)jarg1;
59411   if (!arg1) {
59412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59413     return 0;
59414   }
59415   {
59416     try {
59417       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59433   return jresult;
59434 }
59435
59436
59437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59438   void * jresult ;
59439   Dali::Property::Array *arg1 = 0 ;
59440   Dali::Toolkit::TransitionData result;
59441
59442   arg1 = (Dali::Property::Array *)jarg1;
59443   if (!arg1) {
59444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59445     return 0;
59446   }
59447   {
59448     try {
59449       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59450     } catch (std::out_of_range& e) {
59451       {
59452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (std::exception& e) {
59455       {
59456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59470   void * jresult ;
59471   Dali::BaseHandle arg1 ;
59472   Dali::BaseHandle *argp1 ;
59473   Dali::Toolkit::TransitionData result;
59474
59475   argp1 = (Dali::BaseHandle *)jarg1;
59476   if (!argp1) {
59477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59478     return 0;
59479   }
59480   arg1 = *argp1;
59481   {
59482     try {
59483       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (...) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59495       };
59496     }
59497   }
59498   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59504   void * jresult ;
59505   Dali::Toolkit::TransitionData *arg1 = 0 ;
59506   Dali::Toolkit::TransitionData *result = 0 ;
59507
59508   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59509   if (!arg1) {
59510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59511     return 0;
59512   }
59513   {
59514     try {
59515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59516     } catch (std::out_of_range& e) {
59517       {
59518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59519       };
59520     } catch (std::exception& e) {
59521       {
59522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (...) {
59525       {
59526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59527       };
59528     }
59529   }
59530   jresult = (void *)result;
59531   return jresult;
59532 }
59533
59534
59535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59536   void * jresult ;
59537   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59538   Dali::Toolkit::TransitionData *arg2 = 0 ;
59539   Dali::Toolkit::TransitionData *result = 0 ;
59540
59541   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59542   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59543   if (!arg2) {
59544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59545     return 0;
59546   }
59547   {
59548     try {
59549       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59550     } catch (std::out_of_range& e) {
59551       {
59552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (std::exception& e) {
59555       {
59556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564   jresult = (void *)result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59570   unsigned long jresult ;
59571   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59572   size_t result;
59573
59574   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59575   {
59576     try {
59577       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59578     } catch (std::out_of_range& e) {
59579       {
59580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59581       };
59582     } catch (std::exception& e) {
59583       {
59584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59585       };
59586     } catch (...) {
59587       {
59588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59589       };
59590     }
59591   }
59592   jresult = (unsigned long)result;
59593   return jresult;
59594 }
59595
59596
59597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59598   void * jresult ;
59599   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59600   size_t arg2 ;
59601   Dali::Property::Map result;
59602
59603   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59604   arg2 = (size_t)jarg2;
59605   {
59606     try {
59607       result = (arg1)->GetAnimatorAt(arg2);
59608     } catch (std::out_of_range& e) {
59609       {
59610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (std::exception& e) {
59613       {
59614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (...) {
59617       {
59618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59619       };
59620     }
59621   }
59622   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59628   void * jresult ;
59629   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59630   Dali::Toolkit::TransitionData *result = 0 ;
59631
59632   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59633   {
59634     try {
59635       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59636     } catch (std::out_of_range& e) {
59637       {
59638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59639       };
59640     } catch (std::exception& e) {
59641       {
59642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (...) {
59645       {
59646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59647       };
59648     }
59649   }
59650   jresult = (void *)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59656   int jresult ;
59657   int result;
59658
59659   {
59660     try {
59661       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676   jresult = (int)result;
59677   return jresult;
59678 }
59679
59680
59681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59682   int jresult ;
59683   int result;
59684
59685   {
59686     try {
59687       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59688     } catch (std::out_of_range& e) {
59689       {
59690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (std::exception& e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (...) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59699       };
59700     }
59701   }
59702   jresult = (int)result;
59703   return jresult;
59704 }
59705
59706
59707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59708   int jresult ;
59709   int result;
59710
59711   {
59712     try {
59713       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59714     } catch (std::out_of_range& e) {
59715       {
59716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59717       };
59718     } catch (std::exception& e) {
59719       {
59720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59721       };
59722     } catch (...) {
59723       {
59724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59725       };
59726     }
59727   }
59728   jresult = (int)result;
59729   return jresult;
59730 }
59731
59732
59733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59734   int jresult ;
59735   int result;
59736
59737   {
59738     try {
59739       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59740     } catch (std::out_of_range& e) {
59741       {
59742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (std::exception& e) {
59745       {
59746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (...) {
59749       {
59750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59751       };
59752     }
59753   }
59754   jresult = (int)result;
59755   return jresult;
59756 }
59757
59758
59759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59760   int jresult ;
59761   int result;
59762
59763   {
59764     try {
59765       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59766     } catch (std::out_of_range& e) {
59767       {
59768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59769       };
59770     } catch (std::exception& e) {
59771       {
59772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59773       };
59774     } catch (...) {
59775       {
59776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59777       };
59778     }
59779   }
59780   jresult = (int)result;
59781   return jresult;
59782 }
59783
59784
59785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59786   int jresult ;
59787   int result;
59788
59789   {
59790     try {
59791       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59792     } catch (std::out_of_range& e) {
59793       {
59794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (std::exception& e) {
59797       {
59798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59803       };
59804     }
59805   }
59806   jresult = (int)result;
59807   return jresult;
59808 }
59809
59810
59811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59812   int jresult ;
59813   int result;
59814
59815   {
59816     try {
59817       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59818     } catch (std::out_of_range& e) {
59819       {
59820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59821       };
59822     } catch (std::exception& e) {
59823       {
59824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (...) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59829       };
59830     }
59831   }
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836
59837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59838   int jresult ;
59839   int result;
59840
59841   {
59842     try {
59843       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59844     } catch (std::out_of_range& e) {
59845       {
59846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59847       };
59848     } catch (std::exception& e) {
59849       {
59850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (...) {
59853       {
59854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59855       };
59856     }
59857   }
59858   jresult = (int)result;
59859   return jresult;
59860 }
59861
59862
59863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59864   int jresult ;
59865   int result;
59866
59867   {
59868     try {
59869       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59870     } catch (std::out_of_range& e) {
59871       {
59872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59873       };
59874     } catch (std::exception& e) {
59875       {
59876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59877       };
59878     } catch (...) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59881       };
59882     }
59883   }
59884   jresult = (int)result;
59885   return jresult;
59886 }
59887
59888
59889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59890   int jresult ;
59891   int result;
59892
59893   {
59894     try {
59895       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59896     } catch (std::out_of_range& e) {
59897       {
59898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59899       };
59900     } catch (std::exception& e) {
59901       {
59902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59903       };
59904     } catch (...) {
59905       {
59906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59907       };
59908     }
59909   }
59910   jresult = (int)result;
59911   return jresult;
59912 }
59913
59914
59915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59916   int jresult ;
59917   int result;
59918
59919   {
59920     try {
59921       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59922     } catch (std::out_of_range& e) {
59923       {
59924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59925       };
59926     } catch (std::exception& e) {
59927       {
59928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (...) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59933       };
59934     }
59935   }
59936   jresult = (int)result;
59937   return jresult;
59938 }
59939
59940
59941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59942   int jresult ;
59943   int result;
59944
59945   {
59946     try {
59947       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59948     } catch (std::out_of_range& e) {
59949       {
59950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59951       };
59952     } catch (std::exception& e) {
59953       {
59954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (...) {
59957       {
59958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59959       };
59960     }
59961   }
59962   jresult = (int)result;
59963   return jresult;
59964 }
59965
59966
59967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59968   int jresult ;
59969   int result;
59970
59971   {
59972     try {
59973       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59974     } catch (std::out_of_range& e) {
59975       {
59976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59977       };
59978     } catch (std::exception& e) {
59979       {
59980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (...) {
59983       {
59984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59985       };
59986     }
59987   }
59988   jresult = (int)result;
59989   return jresult;
59990 }
59991
59992
59993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59994   int jresult ;
59995   int result;
59996
59997   {
59998     try {
59999       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
60000     } catch (std::out_of_range& e) {
60001       {
60002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60003       };
60004     } catch (std::exception& e) {
60005       {
60006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (...) {
60009       {
60010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60011       };
60012     }
60013   }
60014   jresult = (int)result;
60015   return jresult;
60016 }
60017
60018
60019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
60020   void * jresult ;
60021   Dali::Toolkit::Control result;
60022
60023   {
60024     try {
60025       result = Dali::Toolkit::Internal::Control::New();
60026     } catch (std::out_of_range& e) {
60027       {
60028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (std::exception& e) {
60031       {
60032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60041   return jresult;
60042 }
60043
60044
60045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60047   std::string *arg2 = 0 ;
60048
60049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60050   if (!jarg2) {
60051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60052     return ;
60053   }
60054   std::string arg2_str(jarg2);
60055   arg2 = &arg2_str;
60056   {
60057     try {
60058       (arg1)->SetStyleName((std::string const &)*arg2);
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60070       };
60071     }
60072   }
60073
60074   //argout typemap for const std::string&
60075
60076 }
60077
60078
60079 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60080   char * jresult ;
60081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60082   std::string *result = 0 ;
60083
60084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60085   {
60086     try {
60087       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60088     } catch (std::out_of_range& e) {
60089       {
60090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (std::exception& e) {
60093       {
60094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102   jresult = SWIG_csharp_string_callback(result->c_str());
60103   return jresult;
60104 }
60105
60106
60107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60109   Dali::Vector4 *arg2 = 0 ;
60110
60111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60112   arg2 = (Dali::Vector4 *)jarg2;
60113   if (!arg2) {
60114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60115     return ;
60116   }
60117   {
60118     try {
60119       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60120     } catch (std::out_of_range& e) {
60121       {
60122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60123       };
60124     } catch (std::exception& e) {
60125       {
60126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60127       };
60128     } catch (...) {
60129       {
60130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60131       };
60132     }
60133   }
60134 }
60135
60136
60137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60138   void * jresult ;
60139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60140   Dali::Vector4 result;
60141
60142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60143   {
60144     try {
60145       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60146     } catch (std::out_of_range& e) {
60147       {
60148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60149       };
60150     } catch (std::exception& e) {
60151       {
60152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60153       };
60154     } catch (...) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60157       };
60158     }
60159   }
60160   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60161   return jresult;
60162 }
60163
60164
60165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60167   Dali::Image arg2 ;
60168   Dali::Image *argp2 ;
60169
60170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60171   argp2 = (Dali::Image *)jarg2;
60172   if (!argp2) {
60173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60174     return ;
60175   }
60176   arg2 = *argp2;
60177   {
60178     try {
60179       (arg1)->SetBackgroundImage(arg2);
60180     } catch (std::out_of_range& e) {
60181       {
60182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60183       };
60184     } catch (std::exception& e) {
60185       {
60186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60187       };
60188     } catch (...) {
60189       {
60190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60191       };
60192     }
60193   }
60194 }
60195
60196
60197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60199   Dali::Property::Map *arg2 = 0 ;
60200
60201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60202   arg2 = (Dali::Property::Map *)jarg2;
60203   if (!arg2) {
60204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60205     return ;
60206   }
60207   {
60208     try {
60209       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60210     } catch (std::out_of_range& e) {
60211       {
60212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60213       };
60214     } catch (std::exception& e) {
60215       {
60216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60217       };
60218     } catch (...) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60221       };
60222     }
60223   }
60224 }
60225
60226
60227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60229
60230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60231   {
60232     try {
60233       (arg1)->ClearBackground();
60234     } catch (std::out_of_range& e) {
60235       {
60236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60237       };
60238     } catch (std::exception& e) {
60239       {
60240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60241       };
60242     } catch (...) {
60243       {
60244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60245       };
60246     }
60247   }
60248 }
60249
60250
60251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60253   Dali::Gesture::Type arg2 ;
60254
60255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60256   arg2 = (Dali::Gesture::Type)jarg2;
60257   {
60258     try {
60259       (arg1)->EnableGestureDetection(arg2);
60260     } catch (std::out_of_range& e) {
60261       {
60262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60263       };
60264     } catch (std::exception& e) {
60265       {
60266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (...) {
60269       {
60270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60271       };
60272     }
60273   }
60274 }
60275
60276
60277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60279   Dali::Gesture::Type arg2 ;
60280
60281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60282   arg2 = (Dali::Gesture::Type)jarg2;
60283   {
60284     try {
60285       (arg1)->DisableGestureDetection(arg2);
60286     } catch (std::out_of_range& e) {
60287       {
60288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60289       };
60290     } catch (std::exception& e) {
60291       {
60292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60293       };
60294     } catch (...) {
60295       {
60296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60297       };
60298     }
60299   }
60300 }
60301
60302
60303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60304   void * jresult ;
60305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60306   Dali::PinchGestureDetector result;
60307
60308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60309   {
60310     try {
60311       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60312     } catch (std::out_of_range& e) {
60313       {
60314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60315       };
60316     } catch (std::exception& e) {
60317       {
60318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (...) {
60321       {
60322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60323       };
60324     }
60325   }
60326   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60327   return jresult;
60328 }
60329
60330
60331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60332   void * jresult ;
60333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60334   Dali::PanGestureDetector result;
60335
60336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60337   {
60338     try {
60339       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60340     } catch (std::out_of_range& e) {
60341       {
60342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60343       };
60344     } catch (std::exception& e) {
60345       {
60346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60347       };
60348     } catch (...) {
60349       {
60350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60351       };
60352     }
60353   }
60354   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60355   return jresult;
60356 }
60357
60358
60359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60360   void * jresult ;
60361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60362   Dali::TapGestureDetector result;
60363
60364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60365   {
60366     try {
60367       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60368     } catch (std::out_of_range& e) {
60369       {
60370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60371       };
60372     } catch (std::exception& e) {
60373       {
60374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (...) {
60377       {
60378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60379       };
60380     }
60381   }
60382   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60383   return jresult;
60384 }
60385
60386
60387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60388   void * jresult ;
60389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60390   Dali::LongPressGestureDetector result;
60391
60392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60393   {
60394     try {
60395       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (...) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60407       };
60408     }
60409   }
60410   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60411   return jresult;
60412 }
60413
60414
60415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60417   bool arg2 ;
60418
60419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60420   arg2 = jarg2 ? true : false;
60421   {
60422     try {
60423       (arg1)->SetKeyboardNavigationSupport(arg2);
60424     } catch (std::out_of_range& e) {
60425       {
60426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60427       };
60428     } catch (std::exception& e) {
60429       {
60430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60431       };
60432     } catch (...) {
60433       {
60434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60435       };
60436     }
60437   }
60438 }
60439
60440
60441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60442   unsigned int jresult ;
60443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60444   bool result;
60445
60446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60447   {
60448     try {
60449       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60450     } catch (std::out_of_range& e) {
60451       {
60452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60453       };
60454     } catch (std::exception& e) {
60455       {
60456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60457       };
60458     } catch (...) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60461       };
60462     }
60463   }
60464   jresult = result;
60465   return jresult;
60466 }
60467
60468
60469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60471
60472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60473   {
60474     try {
60475       (arg1)->SetKeyInputFocus();
60476     } catch (std::out_of_range& e) {
60477       {
60478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60479       };
60480     } catch (std::exception& e) {
60481       {
60482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60487       };
60488     }
60489   }
60490 }
60491
60492
60493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60494   unsigned int jresult ;
60495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60496   bool result;
60497
60498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60499   {
60500     try {
60501       result = (bool)(arg1)->HasKeyInputFocus();
60502     } catch (std::out_of_range& e) {
60503       {
60504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60505       };
60506     } catch (std::exception& e) {
60507       {
60508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60509       };
60510     } catch (...) {
60511       {
60512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60513       };
60514     }
60515   }
60516   jresult = result;
60517   return jresult;
60518 }
60519
60520
60521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60523
60524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60525   {
60526     try {
60527       (arg1)->ClearKeyInputFocus();
60528     } catch (std::out_of_range& e) {
60529       {
60530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60531       };
60532     } catch (std::exception& e) {
60533       {
60534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60535       };
60536     } catch (...) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60539       };
60540     }
60541   }
60542 }
60543
60544
60545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60547   bool arg2 ;
60548
60549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60550   arg2 = jarg2 ? true : false;
60551   {
60552     try {
60553       (arg1)->SetAsKeyboardFocusGroup(arg2);
60554     } catch (std::out_of_range& e) {
60555       {
60556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60557       };
60558     } catch (std::exception& e) {
60559       {
60560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60565       };
60566     }
60567   }
60568 }
60569
60570
60571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60572   unsigned int jresult ;
60573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60574   bool result;
60575
60576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60577   {
60578     try {
60579       result = (bool)(arg1)->IsKeyboardFocusGroup();
60580     } catch (std::out_of_range& e) {
60581       {
60582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (std::exception& e) {
60585       {
60586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594   jresult = result;
60595   return jresult;
60596 }
60597
60598
60599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60601
60602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60603   {
60604     try {
60605       (arg1)->AccessibilityActivate();
60606     } catch (std::out_of_range& e) {
60607       {
60608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60609       };
60610     } catch (std::exception& e) {
60611       {
60612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60613       };
60614     } catch (...) {
60615       {
60616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60617       };
60618     }
60619   }
60620 }
60621
60622
60623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60625
60626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60627   {
60628     try {
60629       (arg1)->KeyboardEnter();
60630     } catch (std::out_of_range& e) {
60631       {
60632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60633       };
60634     } catch (std::exception& e) {
60635       {
60636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60637       };
60638     } catch (...) {
60639       {
60640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60641       };
60642     }
60643   }
60644 }
60645
60646
60647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60648   void * jresult ;
60649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60650   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60651
60652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60653   {
60654     try {
60655       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60656     } catch (std::out_of_range& e) {
60657       {
60658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (std::exception& e) {
60661       {
60662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60667       };
60668     }
60669   }
60670   jresult = (void *)result;
60671   return jresult;
60672 }
60673
60674
60675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60676   void * jresult ;
60677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60678   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60679
60680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60681   {
60682     try {
60683       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60684     } catch (std::out_of_range& e) {
60685       {
60686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60687       };
60688     } catch (std::exception& e) {
60689       {
60690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60691       };
60692     } catch (...) {
60693       {
60694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60695       };
60696     }
60697   }
60698   jresult = (void *)result;
60699   return jresult;
60700 }
60701
60702
60703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60704   void * jresult ;
60705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60706   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60707
60708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60709   {
60710     try {
60711       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60712     } catch (std::out_of_range& e) {
60713       {
60714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (std::exception& e) {
60717       {
60718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (...) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60723       };
60724     }
60725   }
60726   jresult = (void *)result;
60727   return jresult;
60728 }
60729
60730
60731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60732   unsigned int jresult ;
60733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60734   Dali::KeyEvent *arg2 = 0 ;
60735   bool result;
60736
60737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60738   arg2 = (Dali::KeyEvent *)jarg2;
60739   if (!arg2) {
60740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60741     return 0;
60742   }
60743   {
60744     try {
60745       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60746     } catch (std::out_of_range& e) {
60747       {
60748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (std::exception& e) {
60751       {
60752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60753       };
60754     } catch (...) {
60755       {
60756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60757       };
60758     }
60759   }
60760   jresult = result;
60761   return jresult;
60762 }
60763
60764
60765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60767   int arg2 ;
60768   SwigDirector_ViewImpl *darg = 0;
60769
60770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60771   arg2 = (int)jarg2;
60772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60773   {
60774     try {
60775       (darg)->OnStageConnection(arg2);
60776     } catch (std::out_of_range& e) {
60777       {
60778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60779       };
60780     } catch (std::exception& e) {
60781       {
60782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60783       };
60784     } catch (...) {
60785       {
60786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60787       };
60788     }
60789   }
60790 }
60791
60792
60793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60795   int arg2 ;
60796   SwigDirector_ViewImpl *darg = 0;
60797
60798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60799   arg2 = (int)jarg2;
60800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60801   {
60802     try {
60803       (darg)->OnStageConnectionSwigPublic(arg2);
60804     } catch (std::out_of_range& e) {
60805       {
60806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60807       };
60808     } catch (std::exception& e) {
60809       {
60810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (...) {
60813       {
60814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60815       };
60816     }
60817   }
60818 }
60819
60820
60821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60823   SwigDirector_ViewImpl *darg = 0;
60824
60825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60827   {
60828     try {
60829       (darg)->OnStageDisconnection();
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60837       };
60838     } catch (...) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60841       };
60842     }
60843   }
60844 }
60845
60846
60847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60849   SwigDirector_ViewImpl *darg = 0;
60850
60851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60853   {
60854     try {
60855       (darg)->OnStageDisconnectionSwigPublic();
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60867       };
60868     }
60869   }
60870 }
60871
60872
60873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60875   Dali::Actor *arg2 = 0 ;
60876   SwigDirector_ViewImpl *darg = 0;
60877
60878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60879   arg2 = (Dali::Actor *)jarg2;
60880   if (!arg2) {
60881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60882     return ;
60883   }
60884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60885   {
60886     try {
60887       (darg)->OnChildAdd(*arg2);
60888     } catch (std::out_of_range& e) {
60889       {
60890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60891       };
60892     } catch (std::exception& e) {
60893       {
60894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60899       };
60900     }
60901   }
60902 }
60903
60904
60905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60907   Dali::Actor *arg2 = 0 ;
60908   SwigDirector_ViewImpl *darg = 0;
60909
60910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60911   arg2 = (Dali::Actor *)jarg2;
60912   if (!arg2) {
60913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60914     return ;
60915   }
60916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60917   {
60918     try {
60919       (darg)->OnChildAddSwigPublic(*arg2);
60920     } catch (std::out_of_range& e) {
60921       {
60922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60923       };
60924     } catch (std::exception& e) {
60925       {
60926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60931       };
60932     }
60933   }
60934 }
60935
60936
60937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60939   Dali::Actor *arg2 = 0 ;
60940   SwigDirector_ViewImpl *darg = 0;
60941
60942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60943   arg2 = (Dali::Actor *)jarg2;
60944   if (!arg2) {
60945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60946     return ;
60947   }
60948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60949   {
60950     try {
60951       (darg)->OnChildRemove(*arg2);
60952     } catch (std::out_of_range& e) {
60953       {
60954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60955       };
60956     } catch (std::exception& e) {
60957       {
60958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60963       };
60964     }
60965   }
60966 }
60967
60968
60969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60971   Dali::Actor *arg2 = 0 ;
60972   SwigDirector_ViewImpl *darg = 0;
60973
60974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60975   arg2 = (Dali::Actor *)jarg2;
60976   if (!arg2) {
60977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60978     return ;
60979   }
60980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60981   {
60982     try {
60983       (darg)->OnChildRemoveSwigPublic(*arg2);
60984     } catch (std::out_of_range& e) {
60985       {
60986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60987       };
60988     } catch (std::exception& e) {
60989       {
60990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60991       };
60992     } catch (...) {
60993       {
60994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60995       };
60996     }
60997   }
60998 }
60999
61000
61001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
61002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61003   Dali::Property::Index arg2 ;
61004   Dali::Property::Value arg3 ;
61005   Dali::Property::Value *argp3 ;
61006   SwigDirector_ViewImpl *darg = 0;
61007
61008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61009   arg2 = (Dali::Property::Index)jarg2;
61010   argp3 = (Dali::Property::Value *)jarg3;
61011   if (!argp3) {
61012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61013     return ;
61014   }
61015   arg3 = *argp3;
61016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61017   {
61018     try {
61019       (darg)->OnPropertySet(arg2,arg3);
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61031       };
61032     }
61033   }
61034 }
61035
61036
61037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61039   Dali::Property::Index arg2 ;
61040   Dali::Property::Value arg3 ;
61041   Dali::Property::Value *argp3 ;
61042   SwigDirector_ViewImpl *darg = 0;
61043
61044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61045   arg2 = (Dali::Property::Index)jarg2;
61046   argp3 = (Dali::Property::Value *)jarg3;
61047   if (!argp3) {
61048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61049     return ;
61050   }
61051   arg3 = *argp3;
61052   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61053   {
61054     try {
61055       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61056     } catch (std::out_of_range& e) {
61057       {
61058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61059       };
61060     } catch (std::exception& e) {
61061       {
61062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61063       };
61064     } catch (...) {
61065       {
61066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61067       };
61068     }
61069   }
61070 }
61071
61072
61073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61075   Dali::Vector3 *arg2 = 0 ;
61076   SwigDirector_ViewImpl *darg = 0;
61077
61078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61079   arg2 = (Dali::Vector3 *)jarg2;
61080   if (!arg2) {
61081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61082     return ;
61083   }
61084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61085   {
61086     try {
61087       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61088     } catch (std::out_of_range& e) {
61089       {
61090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61091       };
61092     } catch (std::exception& e) {
61093       {
61094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61095       };
61096     } catch (...) {
61097       {
61098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61099       };
61100     }
61101   }
61102 }
61103
61104
61105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61107   Dali::Vector3 *arg2 = 0 ;
61108   SwigDirector_ViewImpl *darg = 0;
61109
61110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61111   arg2 = (Dali::Vector3 *)jarg2;
61112   if (!arg2) {
61113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61114     return ;
61115   }
61116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61117   {
61118     try {
61119       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61120     } catch (std::out_of_range& e) {
61121       {
61122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61123       };
61124     } catch (std::exception& e) {
61125       {
61126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61127       };
61128     } catch (...) {
61129       {
61130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61131       };
61132     }
61133   }
61134 }
61135
61136
61137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61139   Dali::Animation *arg2 = 0 ;
61140   Dali::Vector3 *arg3 = 0 ;
61141   SwigDirector_ViewImpl *darg = 0;
61142
61143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61144   arg2 = (Dali::Animation *)jarg2;
61145   if (!arg2) {
61146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61147     return ;
61148   }
61149   arg3 = (Dali::Vector3 *)jarg3;
61150   if (!arg3) {
61151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61152     return ;
61153   }
61154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61155   {
61156     try {
61157       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61158     } catch (std::out_of_range& e) {
61159       {
61160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61161       };
61162     } catch (std::exception& e) {
61163       {
61164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61165       };
61166     } catch (...) {
61167       {
61168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61169       };
61170     }
61171   }
61172 }
61173
61174
61175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61177   Dali::Animation *arg2 = 0 ;
61178   Dali::Vector3 *arg3 = 0 ;
61179   SwigDirector_ViewImpl *darg = 0;
61180
61181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61182   arg2 = (Dali::Animation *)jarg2;
61183   if (!arg2) {
61184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61185     return ;
61186   }
61187   arg3 = (Dali::Vector3 *)jarg3;
61188   if (!arg3) {
61189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61190     return ;
61191   }
61192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61193   {
61194     try {
61195       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61203       };
61204     } catch (...) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61207       };
61208     }
61209   }
61210 }
61211
61212
61213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61214   unsigned int jresult ;
61215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61216   Dali::TouchEvent *arg2 = 0 ;
61217   SwigDirector_ViewImpl *darg = 0;
61218   bool result;
61219
61220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61221   arg2 = (Dali::TouchEvent *)jarg2;
61222   if (!arg2) {
61223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61224     return 0;
61225   }
61226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61227   {
61228     try {
61229       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61230     } catch (std::out_of_range& e) {
61231       {
61232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61233       };
61234     } catch (std::exception& e) {
61235       {
61236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61241       };
61242     }
61243   }
61244   jresult = result;
61245   return jresult;
61246 }
61247
61248
61249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61250   unsigned int jresult ;
61251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61252   Dali::TouchEvent *arg2 = 0 ;
61253   SwigDirector_ViewImpl *darg = 0;
61254   bool result;
61255
61256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61257   arg2 = (Dali::TouchEvent *)jarg2;
61258   if (!arg2) {
61259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61260     return 0;
61261   }
61262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61263   {
61264     try {
61265       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61266     } catch (std::out_of_range& e) {
61267       {
61268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61269       };
61270     } catch (std::exception& e) {
61271       {
61272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61273       };
61274     } catch (...) {
61275       {
61276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61277       };
61278     }
61279   }
61280   jresult = result;
61281   return jresult;
61282 }
61283
61284
61285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61286   unsigned int jresult ;
61287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61288   Dali::HoverEvent *arg2 = 0 ;
61289   SwigDirector_ViewImpl *darg = 0;
61290   bool result;
61291
61292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61293   arg2 = (Dali::HoverEvent *)jarg2;
61294   if (!arg2) {
61295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61296     return 0;
61297   }
61298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61299   {
61300     try {
61301       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61309       };
61310     } catch (...) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61313       };
61314     }
61315   }
61316   jresult = result;
61317   return jresult;
61318 }
61319
61320
61321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61322   unsigned int jresult ;
61323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61324   Dali::HoverEvent *arg2 = 0 ;
61325   SwigDirector_ViewImpl *darg = 0;
61326   bool result;
61327
61328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61329   arg2 = (Dali::HoverEvent *)jarg2;
61330   if (!arg2) {
61331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61332     return 0;
61333   }
61334   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61335   {
61336     try {
61337       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61345       };
61346     } catch (...) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61349       };
61350     }
61351   }
61352   jresult = result;
61353   return jresult;
61354 }
61355
61356
61357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61358   unsigned int jresult ;
61359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61360   Dali::KeyEvent *arg2 = 0 ;
61361   SwigDirector_ViewImpl *darg = 0;
61362   bool result;
61363
61364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61365   arg2 = (Dali::KeyEvent *)jarg2;
61366   if (!arg2) {
61367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61368     return 0;
61369   }
61370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61371   {
61372     try {
61373       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61374     } catch (std::out_of_range& e) {
61375       {
61376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61377       };
61378     } catch (std::exception& e) {
61379       {
61380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61381       };
61382     } catch (...) {
61383       {
61384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61385       };
61386     }
61387   }
61388   jresult = result;
61389   return jresult;
61390 }
61391
61392
61393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61394   unsigned int jresult ;
61395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61396   Dali::KeyEvent *arg2 = 0 ;
61397   SwigDirector_ViewImpl *darg = 0;
61398   bool result;
61399
61400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61401   arg2 = (Dali::KeyEvent *)jarg2;
61402   if (!arg2) {
61403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61404     return 0;
61405   }
61406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61407   {
61408     try {
61409       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61410     } catch (std::out_of_range& e) {
61411       {
61412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (std::exception& e) {
61415       {
61416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (...) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61421       };
61422     }
61423   }
61424   jresult = result;
61425   return jresult;
61426 }
61427
61428
61429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61430   unsigned int jresult ;
61431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61432   Dali::WheelEvent *arg2 = 0 ;
61433   SwigDirector_ViewImpl *darg = 0;
61434   bool result;
61435
61436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61437   arg2 = (Dali::WheelEvent *)jarg2;
61438   if (!arg2) {
61439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61440     return 0;
61441   }
61442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61443   {
61444     try {
61445       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61446     } catch (std::out_of_range& e) {
61447       {
61448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (std::exception& e) {
61451       {
61452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61457       };
61458     }
61459   }
61460   jresult = result;
61461   return jresult;
61462 }
61463
61464
61465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61466   unsigned int jresult ;
61467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61468   Dali::WheelEvent *arg2 = 0 ;
61469   SwigDirector_ViewImpl *darg = 0;
61470   bool result;
61471
61472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61473   arg2 = (Dali::WheelEvent *)jarg2;
61474   if (!arg2) {
61475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61476     return 0;
61477   }
61478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61479   {
61480     try {
61481       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61482     } catch (std::out_of_range& e) {
61483       {
61484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61485       };
61486     } catch (std::exception& e) {
61487       {
61488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (...) {
61491       {
61492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61493       };
61494     }
61495   }
61496   jresult = result;
61497   return jresult;
61498 }
61499
61500
61501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61503   Dali::Vector2 *arg2 = 0 ;
61504   Dali::RelayoutContainer *arg3 = 0 ;
61505   SwigDirector_ViewImpl *darg = 0;
61506
61507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61508   arg2 = (Dali::Vector2 *)jarg2;
61509   if (!arg2) {
61510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61511     return ;
61512   }
61513   arg3 = (Dali::RelayoutContainer *)jarg3;
61514   if (!arg3) {
61515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61516     return ;
61517   }
61518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61519   {
61520     try {
61521       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61522     } catch (std::out_of_range& e) {
61523       {
61524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61525       };
61526     } catch (std::exception& e) {
61527       {
61528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61529       };
61530     } catch (...) {
61531       {
61532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61533       };
61534     }
61535   }
61536 }
61537
61538
61539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61541   Dali::Vector2 *arg2 = 0 ;
61542   Dali::RelayoutContainer *arg3 = 0 ;
61543   SwigDirector_ViewImpl *darg = 0;
61544
61545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61546   arg2 = (Dali::Vector2 *)jarg2;
61547   if (!arg2) {
61548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61549     return ;
61550   }
61551   arg3 = (Dali::RelayoutContainer *)jarg3;
61552   if (!arg3) {
61553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61554     return ;
61555   }
61556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61557   {
61558     try {
61559       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61560     } catch (std::out_of_range& e) {
61561       {
61562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61563       };
61564     } catch (std::exception& e) {
61565       {
61566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61571       };
61572     }
61573   }
61574 }
61575
61576
61577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61579   Dali::ResizePolicy::Type arg2 ;
61580   Dali::Dimension::Type arg3 ;
61581   SwigDirector_ViewImpl *darg = 0;
61582
61583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61584   arg2 = (Dali::ResizePolicy::Type)jarg2;
61585   arg3 = (Dali::Dimension::Type)jarg3;
61586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61587   {
61588     try {
61589       (darg)->OnSetResizePolicy(arg2,arg3);
61590     } catch (std::out_of_range& e) {
61591       {
61592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61593       };
61594     } catch (std::exception& e) {
61595       {
61596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61597       };
61598     } catch (...) {
61599       {
61600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61601       };
61602     }
61603   }
61604 }
61605
61606
61607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61609   Dali::ResizePolicy::Type arg2 ;
61610   Dali::Dimension::Type arg3 ;
61611   SwigDirector_ViewImpl *darg = 0;
61612
61613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61614   arg2 = (Dali::ResizePolicy::Type)jarg2;
61615   arg3 = (Dali::Dimension::Type)jarg3;
61616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61617   {
61618     try {
61619       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61620     } catch (std::out_of_range& e) {
61621       {
61622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61623       };
61624     } catch (std::exception& e) {
61625       {
61626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61627       };
61628     } catch (...) {
61629       {
61630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61631       };
61632     }
61633   }
61634 }
61635
61636
61637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61638   void * jresult ;
61639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61640   SwigDirector_ViewImpl *darg = 0;
61641   Dali::Vector3 result;
61642
61643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61645   {
61646     try {
61647       result = (darg)->GetNaturalSize();
61648     } catch (std::out_of_range& e) {
61649       {
61650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61651       };
61652     } catch (std::exception& e) {
61653       {
61654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61655       };
61656     } catch (...) {
61657       {
61658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61659       };
61660     }
61661   }
61662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61663   return jresult;
61664 }
61665
61666
61667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61668   void * jresult ;
61669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61670   SwigDirector_ViewImpl *darg = 0;
61671   Dali::Vector3 result;
61672
61673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61674   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61675   {
61676     try {
61677       result = (darg)->GetNaturalSizeSwigPublic();
61678     } catch (std::out_of_range& e) {
61679       {
61680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (std::exception& e) {
61683       {
61684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61685       };
61686     } catch (...) {
61687       {
61688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61689       };
61690     }
61691   }
61692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61693   return jresult;
61694 }
61695
61696
61697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61698   float jresult ;
61699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61700   Dali::Actor *arg2 = 0 ;
61701   Dali::Dimension::Type arg3 ;
61702   SwigDirector_ViewImpl *darg = 0;
61703   float result;
61704
61705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61706   arg2 = (Dali::Actor *)jarg2;
61707   if (!arg2) {
61708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61709     return 0;
61710   }
61711   arg3 = (Dali::Dimension::Type)jarg3;
61712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61713   {
61714     try {
61715       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61716     } catch (std::out_of_range& e) {
61717       {
61718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61719       };
61720     } catch (std::exception& e) {
61721       {
61722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61723       };
61724     } catch (...) {
61725       {
61726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61727       };
61728     }
61729   }
61730   jresult = result;
61731   return jresult;
61732 }
61733
61734
61735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61736   float jresult ;
61737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61738   Dali::Actor *arg2 = 0 ;
61739   Dali::Dimension::Type arg3 ;
61740   SwigDirector_ViewImpl *darg = 0;
61741   float result;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   arg2 = (Dali::Actor *)jarg2;
61745   if (!arg2) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61747     return 0;
61748   }
61749   arg3 = (Dali::Dimension::Type)jarg3;
61750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61751   {
61752     try {
61753       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61754     } catch (std::out_of_range& e) {
61755       {
61756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (std::exception& e) {
61759       {
61760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768   jresult = result;
61769   return jresult;
61770 }
61771
61772
61773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61774   float jresult ;
61775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61776   float arg2 ;
61777   SwigDirector_ViewImpl *darg = 0;
61778   float result;
61779
61780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61781   arg2 = (float)jarg2;
61782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61783   {
61784     try {
61785       result = (float)(darg)->GetHeightForWidth(arg2);
61786     } catch (std::out_of_range& e) {
61787       {
61788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61789       };
61790     } catch (std::exception& e) {
61791       {
61792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61793       };
61794     } catch (...) {
61795       {
61796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61797       };
61798     }
61799   }
61800   jresult = result;
61801   return jresult;
61802 }
61803
61804
61805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61806   float jresult ;
61807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61808   float arg2 ;
61809   SwigDirector_ViewImpl *darg = 0;
61810   float result;
61811
61812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61813   arg2 = (float)jarg2;
61814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61815   {
61816     try {
61817       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61818     } catch (std::out_of_range& e) {
61819       {
61820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61821       };
61822     } catch (std::exception& e) {
61823       {
61824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61825       };
61826     } catch (...) {
61827       {
61828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61829       };
61830     }
61831   }
61832   jresult = result;
61833   return jresult;
61834 }
61835
61836
61837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61838   float jresult ;
61839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61840   float arg2 ;
61841   SwigDirector_ViewImpl *darg = 0;
61842   float result;
61843
61844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61845   arg2 = (float)jarg2;
61846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61847   {
61848     try {
61849       result = (float)(darg)->GetWidthForHeight(arg2);
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (...) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61861       };
61862     }
61863   }
61864   jresult = result;
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61870   float jresult ;
61871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61872   float arg2 ;
61873   SwigDirector_ViewImpl *darg = 0;
61874   float result;
61875
61876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61877   arg2 = (float)jarg2;
61878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61879   {
61880     try {
61881       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61882     } catch (std::out_of_range& e) {
61883       {
61884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61885       };
61886     } catch (std::exception& e) {
61887       {
61888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61889       };
61890     } catch (...) {
61891       {
61892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61893       };
61894     }
61895   }
61896   jresult = result;
61897   return jresult;
61898 }
61899
61900
61901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61902   unsigned int jresult ;
61903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61904   Dali::Dimension::Type arg2 ;
61905   SwigDirector_ViewImpl *darg = 0;
61906   bool result;
61907
61908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61909   arg2 = (Dali::Dimension::Type)jarg2;
61910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61911   {
61912     try {
61913       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61914     } catch (std::out_of_range& e) {
61915       {
61916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61917       };
61918     } catch (std::exception& e) {
61919       {
61920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61921       };
61922     } catch (...) {
61923       {
61924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61925       };
61926     }
61927   }
61928   jresult = result;
61929   return jresult;
61930 }
61931
61932
61933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61934   unsigned int jresult ;
61935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61936   Dali::Dimension::Type arg2 ;
61937   SwigDirector_ViewImpl *darg = 0;
61938   bool result;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   arg2 = (Dali::Dimension::Type)jarg2;
61942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61943   {
61944     try {
61945       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61946     } catch (std::out_of_range& e) {
61947       {
61948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61949       };
61950     } catch (std::exception& e) {
61951       {
61952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61953       };
61954     } catch (...) {
61955       {
61956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61957       };
61958     }
61959   }
61960   jresult = result;
61961   return jresult;
61962 }
61963
61964
61965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61966   unsigned int jresult ;
61967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61968   SwigDirector_ViewImpl *darg = 0;
61969   bool result;
61970
61971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61972   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61973   {
61974     try {
61975       result = (bool)(darg)->RelayoutDependentOnChildren();
61976     } catch (std::out_of_range& e) {
61977       {
61978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61979       };
61980     } catch (std::exception& e) {
61981       {
61982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61983       };
61984     } catch (...) {
61985       {
61986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61987       };
61988     }
61989   }
61990   jresult = result;
61991   return jresult;
61992 }
61993
61994
61995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61996   unsigned int jresult ;
61997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61998   SwigDirector_ViewImpl *darg = 0;
61999   bool result;
62000
62001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62002   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62003   {
62004     try {
62005       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
62006     } catch (std::out_of_range& e) {
62007       {
62008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62009       };
62010     } catch (std::exception& e) {
62011       {
62012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62013       };
62014     } catch (...) {
62015       {
62016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62017       };
62018     }
62019   }
62020   jresult = result;
62021   return jresult;
62022 }
62023
62024
62025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62027   Dali::Dimension::Type arg2 ;
62028   SwigDirector_ViewImpl *darg = 0;
62029
62030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62031   arg2 = (Dali::Dimension::Type)jarg2;
62032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62033   {
62034     try {
62035       (darg)->OnCalculateRelayoutSize(arg2);
62036     } catch (std::out_of_range& e) {
62037       {
62038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62039       };
62040     } catch (std::exception& e) {
62041       {
62042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62043       };
62044     } catch (...) {
62045       {
62046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62047       };
62048     }
62049   }
62050 }
62051
62052
62053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62055   Dali::Dimension::Type arg2 ;
62056   SwigDirector_ViewImpl *darg = 0;
62057
62058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62059   arg2 = (Dali::Dimension::Type)jarg2;
62060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62061   {
62062     try {
62063       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62064     } catch (std::out_of_range& e) {
62065       {
62066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62067       };
62068     } catch (std::exception& e) {
62069       {
62070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62071       };
62072     } catch (...) {
62073       {
62074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62075       };
62076     }
62077   }
62078 }
62079
62080
62081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62083   float arg2 ;
62084   Dali::Dimension::Type arg3 ;
62085   SwigDirector_ViewImpl *darg = 0;
62086
62087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62088   arg2 = (float)jarg2;
62089   arg3 = (Dali::Dimension::Type)jarg3;
62090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62091   {
62092     try {
62093       (darg)->OnLayoutNegotiated(arg2,arg3);
62094     } catch (std::out_of_range& e) {
62095       {
62096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62097       };
62098     } catch (std::exception& e) {
62099       {
62100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (...) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62105       };
62106     }
62107   }
62108 }
62109
62110
62111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62113   float arg2 ;
62114   Dali::Dimension::Type arg3 ;
62115   SwigDirector_ViewImpl *darg = 0;
62116
62117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62118   arg2 = (float)jarg2;
62119   arg3 = (Dali::Dimension::Type)jarg3;
62120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62121   {
62122     try {
62123       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62131       };
62132     } catch (...) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62135       };
62136     }
62137   }
62138 }
62139
62140
62141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62143
62144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62145   {
62146     try {
62147       (arg1)->OnInitialize();
62148     } catch (std::out_of_range& e) {
62149       {
62150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62151       };
62152     } catch (std::exception& e) {
62153       {
62154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62155       };
62156     } catch (...) {
62157       {
62158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62159       };
62160     }
62161   }
62162 }
62163
62164
62165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62167
62168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62169   {
62170     try {
62171       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62172     } catch (std::out_of_range& e) {
62173       {
62174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62175       };
62176     } catch (std::exception& e) {
62177       {
62178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62179       };
62180     } catch (...) {
62181       {
62182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62183       };
62184     }
62185   }
62186 }
62187
62188
62189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62191   Dali::Actor *arg2 = 0 ;
62192
62193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62194   arg2 = (Dali::Actor *)jarg2;
62195   if (!arg2) {
62196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62197     return ;
62198   }
62199   {
62200     try {
62201       (arg1)->OnControlChildAdd(*arg2);
62202     } catch (std::out_of_range& e) {
62203       {
62204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62205       };
62206     } catch (std::exception& e) {
62207       {
62208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62209       };
62210     } catch (...) {
62211       {
62212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62213       };
62214     }
62215   }
62216 }
62217
62218
62219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62221   Dali::Actor *arg2 = 0 ;
62222
62223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62224   arg2 = (Dali::Actor *)jarg2;
62225   if (!arg2) {
62226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62227     return ;
62228   }
62229   {
62230     try {
62231       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62232     } catch (std::out_of_range& e) {
62233       {
62234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62235       };
62236     } catch (std::exception& e) {
62237       {
62238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (...) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62243       };
62244     }
62245   }
62246 }
62247
62248
62249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62251   Dali::Actor *arg2 = 0 ;
62252
62253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62254   arg2 = (Dali::Actor *)jarg2;
62255   if (!arg2) {
62256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62257     return ;
62258   }
62259   {
62260     try {
62261       (arg1)->OnControlChildRemove(*arg2);
62262     } catch (std::out_of_range& e) {
62263       {
62264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62265       };
62266     } catch (std::exception& e) {
62267       {
62268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62269       };
62270     } catch (...) {
62271       {
62272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62273       };
62274     }
62275   }
62276 }
62277
62278
62279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62281   Dali::Actor *arg2 = 0 ;
62282
62283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62284   arg2 = (Dali::Actor *)jarg2;
62285   if (!arg2) {
62286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62287     return ;
62288   }
62289   {
62290     try {
62291       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62292     } catch (std::out_of_range& e) {
62293       {
62294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62295       };
62296     } catch (std::exception& e) {
62297       {
62298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62299       };
62300     } catch (...) {
62301       {
62302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62303       };
62304     }
62305   }
62306 }
62307
62308
62309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62311   Dali::Toolkit::StyleManager arg2 ;
62312   Dali::StyleChange::Type arg3 ;
62313   Dali::Toolkit::StyleManager *argp2 ;
62314
62315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62316   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62317   if (!argp2) {
62318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62319     return ;
62320   }
62321   arg2 = *argp2;
62322   arg3 = (Dali::StyleChange::Type)jarg3;
62323   {
62324     try {
62325       (arg1)->OnStyleChange(arg2,arg3);
62326     } catch (std::out_of_range& e) {
62327       {
62328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62329       };
62330     } catch (std::exception& e) {
62331       {
62332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62333       };
62334     } catch (...) {
62335       {
62336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62337       };
62338     }
62339   }
62340 }
62341
62342
62343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62345   Dali::Toolkit::StyleManager arg2 ;
62346   Dali::StyleChange::Type arg3 ;
62347   Dali::Toolkit::StyleManager *argp2 ;
62348
62349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62350   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62351   if (!argp2) {
62352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62353     return ;
62354   }
62355   arg2 = *argp2;
62356   arg3 = (Dali::StyleChange::Type)jarg3;
62357   {
62358     try {
62359       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62360     } catch (std::out_of_range& e) {
62361       {
62362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62363       };
62364     } catch (std::exception& e) {
62365       {
62366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62367       };
62368     } catch (...) {
62369       {
62370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62371       };
62372     }
62373   }
62374 }
62375
62376
62377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62378   unsigned int jresult ;
62379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62380   bool result;
62381
62382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62383   {
62384     try {
62385       result = (bool)(arg1)->OnAccessibilityActivated();
62386     } catch (std::out_of_range& e) {
62387       {
62388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62389       };
62390     } catch (std::exception& e) {
62391       {
62392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62393       };
62394     } catch (...) {
62395       {
62396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62397       };
62398     }
62399   }
62400   jresult = result;
62401   return jresult;
62402 }
62403
62404
62405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62406   unsigned int jresult ;
62407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62408   bool result;
62409
62410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62411   {
62412     try {
62413       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62414     } catch (std::out_of_range& e) {
62415       {
62416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62417       };
62418     } catch (std::exception& e) {
62419       {
62420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (...) {
62423       {
62424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62425       };
62426     }
62427   }
62428   jresult = result;
62429   return jresult;
62430 }
62431
62432
62433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62434   unsigned int jresult ;
62435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62436   Dali::PanGesture arg2 ;
62437   Dali::PanGesture *argp2 ;
62438   bool result;
62439
62440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62441   argp2 = (Dali::PanGesture *)jarg2;
62442   if (!argp2) {
62443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62444     return 0;
62445   }
62446   arg2 = *argp2;
62447   {
62448     try {
62449       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62450     } catch (std::out_of_range& e) {
62451       {
62452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62453       };
62454     } catch (std::exception& e) {
62455       {
62456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62457       };
62458     } catch (...) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62461       };
62462     }
62463   }
62464   jresult = result;
62465   return jresult;
62466 }
62467
62468
62469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62470   unsigned int jresult ;
62471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62472   Dali::PanGesture arg2 ;
62473   Dali::PanGesture *argp2 ;
62474   bool result;
62475
62476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62477   argp2 = (Dali::PanGesture *)jarg2;
62478   if (!argp2) {
62479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62480     return 0;
62481   }
62482   arg2 = *argp2;
62483   {
62484     try {
62485       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (...) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62497       };
62498     }
62499   }
62500   jresult = result;
62501   return jresult;
62502 }
62503
62504
62505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62506   unsigned int jresult ;
62507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62508   Dali::TouchEvent *arg2 = 0 ;
62509   bool result;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   arg2 = (Dali::TouchEvent *)jarg2;
62513   if (!arg2) {
62514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62515     return 0;
62516   }
62517   {
62518     try {
62519       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62520     } catch (std::out_of_range& e) {
62521       {
62522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62523       };
62524     } catch (std::exception& e) {
62525       {
62526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (...) {
62529       {
62530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62531       };
62532     }
62533   }
62534   jresult = result;
62535   return jresult;
62536 }
62537
62538
62539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62540   unsigned int jresult ;
62541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62542   Dali::TouchEvent *arg2 = 0 ;
62543   bool result;
62544
62545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62546   arg2 = (Dali::TouchEvent *)jarg2;
62547   if (!arg2) {
62548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62549     return 0;
62550   }
62551   {
62552     try {
62553       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62554     } catch (std::out_of_range& e) {
62555       {
62556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62557       };
62558     } catch (std::exception& e) {
62559       {
62560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62561       };
62562     } catch (...) {
62563       {
62564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62565       };
62566     }
62567   }
62568   jresult = result;
62569   return jresult;
62570 }
62571
62572
62573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62574   unsigned int jresult ;
62575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62576   bool arg2 ;
62577   bool result;
62578
62579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62580   arg2 = jarg2 ? true : false;
62581   {
62582     try {
62583       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62584     } catch (std::out_of_range& e) {
62585       {
62586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62587       };
62588     } catch (std::exception& e) {
62589       {
62590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62591       };
62592     } catch (...) {
62593       {
62594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62595       };
62596     }
62597   }
62598   jresult = result;
62599   return jresult;
62600 }
62601
62602
62603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62604   unsigned int jresult ;
62605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62606   bool arg2 ;
62607   bool result;
62608
62609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62610   arg2 = jarg2 ? true : false;
62611   {
62612     try {
62613       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62614     } catch (std::out_of_range& e) {
62615       {
62616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62617       };
62618     } catch (std::exception& e) {
62619       {
62620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (...) {
62623       {
62624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62625       };
62626     }
62627   }
62628   jresult = result;
62629   return jresult;
62630 }
62631
62632
62633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62634   unsigned int jresult ;
62635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62636   bool result;
62637
62638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62639   {
62640     try {
62641       result = (bool)(arg1)->OnAccessibilityZoom();
62642     } catch (std::out_of_range& e) {
62643       {
62644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62645       };
62646     } catch (std::exception& e) {
62647       {
62648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62649       };
62650     } catch (...) {
62651       {
62652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62653       };
62654     }
62655   }
62656   jresult = result;
62657   return jresult;
62658 }
62659
62660
62661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62662   unsigned int jresult ;
62663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62664   bool result;
62665
62666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62667   {
62668     try {
62669       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62670     } catch (std::out_of_range& e) {
62671       {
62672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62673       };
62674     } catch (std::exception& e) {
62675       {
62676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62677       };
62678     } catch (...) {
62679       {
62680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62681       };
62682     }
62683   }
62684   jresult = result;
62685   return jresult;
62686 }
62687
62688
62689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62691
62692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62693   {
62694     try {
62695       (arg1)->OnKeyInputFocusGained();
62696     } catch (std::out_of_range& e) {
62697       {
62698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62699       };
62700     } catch (std::exception& e) {
62701       {
62702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62703       };
62704     } catch (...) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62707       };
62708     }
62709   }
62710 }
62711
62712
62713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62715
62716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62717   {
62718     try {
62719       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62720     } catch (std::out_of_range& e) {
62721       {
62722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62723       };
62724     } catch (std::exception& e) {
62725       {
62726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62727       };
62728     } catch (...) {
62729       {
62730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62731       };
62732     }
62733   }
62734 }
62735
62736
62737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62739
62740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62741   {
62742     try {
62743       (arg1)->OnKeyInputFocusLost();
62744     } catch (std::out_of_range& e) {
62745       {
62746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62747       };
62748     } catch (std::exception& e) {
62749       {
62750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62751       };
62752     } catch (...) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62755       };
62756     }
62757   }
62758 }
62759
62760
62761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62763
62764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62765   {
62766     try {
62767       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62768     } catch (std::out_of_range& e) {
62769       {
62770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62771       };
62772     } catch (std::exception& e) {
62773       {
62774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62779       };
62780     }
62781   }
62782 }
62783
62784
62785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62786   void * jresult ;
62787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62788   Dali::Actor arg2 ;
62789   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62790   bool arg4 ;
62791   Dali::Actor *argp2 ;
62792   Dali::Actor result;
62793
62794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62795   argp2 = (Dali::Actor *)jarg2;
62796   if (!argp2) {
62797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62798     return 0;
62799   }
62800   arg2 = *argp2;
62801   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62802   arg4 = jarg4 ? true : false;
62803   {
62804     try {
62805       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62806     } catch (std::out_of_range& e) {
62807       {
62808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62809       };
62810     } catch (std::exception& e) {
62811       {
62812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62813       };
62814     } catch (...) {
62815       {
62816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62817       };
62818     }
62819   }
62820   jresult = new Dali::Actor((const Dali::Actor &)result);
62821   return jresult;
62822 }
62823
62824
62825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62826   void * jresult ;
62827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62828   Dali::Actor arg2 ;
62829   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62830   bool arg4 ;
62831   Dali::Actor *argp2 ;
62832   Dali::Actor result;
62833
62834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62835   argp2 = (Dali::Actor *)jarg2;
62836   if (!argp2) {
62837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62838     return 0;
62839   }
62840   arg2 = *argp2;
62841   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62842   arg4 = jarg4 ? true : false;
62843   {
62844     try {
62845       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62846     } catch (std::out_of_range& e) {
62847       {
62848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62849       };
62850     } catch (std::exception& e) {
62851       {
62852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62857       };
62858     }
62859   }
62860   jresult = new Dali::Actor((const Dali::Actor &)result);
62861   return jresult;
62862 }
62863
62864
62865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62867   Dali::Actor arg2 ;
62868   Dali::Actor *argp2 ;
62869
62870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62871   argp2 = (Dali::Actor *)jarg2;
62872   if (!argp2) {
62873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62874     return ;
62875   }
62876   arg2 = *argp2;
62877   {
62878     try {
62879       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62880     } catch (std::out_of_range& e) {
62881       {
62882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62883       };
62884     } catch (std::exception& e) {
62885       {
62886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62887       };
62888     } catch (...) {
62889       {
62890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62891       };
62892     }
62893   }
62894 }
62895
62896
62897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62899   Dali::Actor arg2 ;
62900   Dali::Actor *argp2 ;
62901
62902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62903   argp2 = (Dali::Actor *)jarg2;
62904   if (!argp2) {
62905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62906     return ;
62907   }
62908   arg2 = *argp2;
62909   {
62910     try {
62911       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62912     } catch (std::out_of_range& e) {
62913       {
62914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62915       };
62916     } catch (std::exception& e) {
62917       {
62918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62919       };
62920     } catch (...) {
62921       {
62922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62923       };
62924     }
62925   }
62926 }
62927
62928
62929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62930   unsigned int jresult ;
62931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62932   bool result;
62933
62934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62935   {
62936     try {
62937       result = (bool)(arg1)->OnKeyboardEnter();
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62949       };
62950     }
62951   }
62952   jresult = result;
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62958   unsigned int jresult ;
62959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62960   bool result;
62961
62962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62963   {
62964     try {
62965       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (...) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62977       };
62978     }
62979   }
62980   jresult = result;
62981   return jresult;
62982 }
62983
62984
62985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62987   Dali::PinchGesture *arg2 = 0 ;
62988
62989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62990   arg2 = (Dali::PinchGesture *)jarg2;
62991   if (!arg2) {
62992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62993     return ;
62994   }
62995   {
62996     try {
62997       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (...) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63009       };
63010     }
63011   }
63012 }
63013
63014
63015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63017   Dali::PinchGesture *arg2 = 0 ;
63018
63019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63020   arg2 = (Dali::PinchGesture *)jarg2;
63021   if (!arg2) {
63022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63023     return ;
63024   }
63025   {
63026     try {
63027       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63028     } catch (std::out_of_range& e) {
63029       {
63030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63031       };
63032     } catch (std::exception& e) {
63033       {
63034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63035       };
63036     } catch (...) {
63037       {
63038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63039       };
63040     }
63041   }
63042 }
63043
63044
63045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63047   Dali::PanGesture *arg2 = 0 ;
63048
63049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63050   arg2 = (Dali::PanGesture *)jarg2;
63051   if (!arg2) {
63052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63053     return ;
63054   }
63055   {
63056     try {
63057       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63058     } catch (std::out_of_range& e) {
63059       {
63060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63061       };
63062     } catch (std::exception& e) {
63063       {
63064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63065       };
63066     } catch (...) {
63067       {
63068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63069       };
63070     }
63071   }
63072 }
63073
63074
63075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63077   Dali::PanGesture *arg2 = 0 ;
63078
63079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63080   arg2 = (Dali::PanGesture *)jarg2;
63081   if (!arg2) {
63082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63083     return ;
63084   }
63085   {
63086     try {
63087       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63088     } catch (std::out_of_range& e) {
63089       {
63090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63091       };
63092     } catch (std::exception& e) {
63093       {
63094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63095       };
63096     } catch (...) {
63097       {
63098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63099       };
63100     }
63101   }
63102 }
63103
63104
63105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63107   Dali::TapGesture *arg2 = 0 ;
63108
63109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63110   arg2 = (Dali::TapGesture *)jarg2;
63111   if (!arg2) {
63112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63113     return ;
63114   }
63115   {
63116     try {
63117       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63118     } catch (std::out_of_range& e) {
63119       {
63120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63121       };
63122     } catch (std::exception& e) {
63123       {
63124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63125       };
63126     } catch (...) {
63127       {
63128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63129       };
63130     }
63131   }
63132 }
63133
63134
63135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63137   Dali::TapGesture *arg2 = 0 ;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   arg2 = (Dali::TapGesture *)jarg2;
63141   if (!arg2) {
63142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63143     return ;
63144   }
63145   {
63146     try {
63147       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63148     } catch (std::out_of_range& e) {
63149       {
63150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (std::exception& e) {
63153       {
63154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63159       };
63160     }
63161   }
63162 }
63163
63164
63165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63167   Dali::LongPressGesture *arg2 = 0 ;
63168
63169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63170   arg2 = (Dali::LongPressGesture *)jarg2;
63171   if (!arg2) {
63172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63173     return ;
63174   }
63175   {
63176     try {
63177       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (...) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63189       };
63190     }
63191   }
63192 }
63193
63194
63195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63197   Dali::LongPressGesture *arg2 = 0 ;
63198
63199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63200   arg2 = (Dali::LongPressGesture *)jarg2;
63201   if (!arg2) {
63202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63203     return ;
63204   }
63205   {
63206     try {
63207       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63208     } catch (std::out_of_range& e) {
63209       {
63210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (std::exception& e) {
63213       {
63214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63215       };
63216     } catch (...) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63219       };
63220     }
63221   }
63222 }
63223
63224
63225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63227   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63228   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63229
63230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63231   arg2 = (Dali::SlotObserver *)jarg2;
63232   arg3 = (Dali::CallbackBase *)jarg3;
63233   {
63234     try {
63235       (arg1)->SignalConnected(arg2,arg3);
63236     } catch (std::out_of_range& e) {
63237       {
63238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63239       };
63240     } catch (std::exception& e) {
63241       {
63242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63243       };
63244     } catch (...) {
63245       {
63246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63247       };
63248     }
63249   }
63250 }
63251
63252
63253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63255   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63256   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63257
63258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63259   arg2 = (Dali::SlotObserver *)jarg2;
63260   arg3 = (Dali::CallbackBase *)jarg3;
63261   {
63262     try {
63263       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63264     } catch (std::out_of_range& e) {
63265       {
63266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63267       };
63268     } catch (std::exception& e) {
63269       {
63270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63271       };
63272     } catch (...) {
63273       {
63274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63275       };
63276     }
63277   }
63278 }
63279
63280
63281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63283   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63284   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63285
63286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63287   arg2 = (Dali::SlotObserver *)jarg2;
63288   arg3 = (Dali::CallbackBase *)jarg3;
63289   {
63290     try {
63291       (arg1)->SignalDisconnected(arg2,arg3);
63292     } catch (std::out_of_range& e) {
63293       {
63294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63295       };
63296     } catch (std::exception& e) {
63297       {
63298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63299       };
63300     } catch (...) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63303       };
63304     }
63305   }
63306 }
63307
63308
63309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63311   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63312   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63313
63314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63315   arg2 = (Dali::SlotObserver *)jarg2;
63316   arg3 = (Dali::CallbackBase *)jarg3;
63317   {
63318     try {
63319       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63320     } catch (std::out_of_range& e) {
63321       {
63322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63323       };
63324     } catch (std::exception& e) {
63325       {
63326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63327       };
63328     } catch (...) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63331       };
63332     }
63333   }
63334 }
63335
63336
63337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback7_t callback7, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback22_t callback22, SwigDirector_ViewImpl::SWIG_Callback23_t callback23, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
63338   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63339   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63340   if (director) {
63341     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
63342   }
63343 }
63344
63345
63346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63347   void * jresult ;
63348   Dali::Toolkit::Control *arg1 = 0 ;
63349   Dali::Toolkit::Internal::Control *result = 0 ;
63350
63351   arg1 = (Dali::Toolkit::Control *)jarg1;
63352   if (!arg1) {
63353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63354     return 0;
63355   }
63356   {
63357     try {
63358       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63359     } catch (std::out_of_range& e) {
63360       {
63361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (std::exception& e) {
63364       {
63365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63370       };
63371     }
63372   }
63373   jresult = (void *)result;
63374   return jresult;
63375 }
63376
63377
63378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63379   int jresult ;
63380   int result;
63381
63382   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63383   jresult = (int)result;
63384   return jresult;
63385 }
63386
63387
63388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63389   int jresult ;
63390   int result;
63391
63392   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63393   jresult = (int)result;
63394   return jresult;
63395 }
63396
63397
63398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63399   int jresult ;
63400   int result;
63401
63402   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63403   jresult = (int)result;
63404   return jresult;
63405 }
63406
63407
63408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63409   int jresult ;
63410   int result;
63411
63412   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63413   jresult = (int)result;
63414   return jresult;
63415 }
63416
63417
63418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63419   int jresult ;
63420   int result;
63421
63422   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63423   jresult = (int)result;
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63429   void * jresult ;
63430   Dali::Toolkit::Control::Property *result = 0 ;
63431
63432   {
63433     try {
63434       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (...) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63446       };
63447     }
63448   }
63449   jresult = (void *)result;
63450   return jresult;
63451 }
63452
63453
63454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63455   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63456
63457   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63458   {
63459     try {
63460       delete arg1;
63461     } catch (std::out_of_range& e) {
63462       {
63463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63464       };
63465     } catch (std::exception& e) {
63466       {
63467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63468       };
63469     } catch (...) {
63470       {
63471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63472       };
63473     }
63474   }
63475 }
63476
63477
63478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63479   void * jresult ;
63480   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63481
63482   {
63483     try {
63484       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63485     } catch (std::out_of_range& e) {
63486       {
63487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63488       };
63489     } catch (std::exception& e) {
63490       {
63491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63496       };
63497     }
63498   }
63499   jresult = (void *)result;
63500   return jresult;
63501 }
63502
63503
63504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63505   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63506
63507   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63508   {
63509     try {
63510       delete arg1;
63511     } catch (std::out_of_range& e) {
63512       {
63513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63514       };
63515     } catch (std::exception& e) {
63516       {
63517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63522       };
63523     }
63524   }
63525 }
63526
63527
63528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63529   void * jresult ;
63530   Dali::Toolkit::Control result;
63531
63532   {
63533     try {
63534       result = Dali::Toolkit::Control::New();
63535     } catch (std::out_of_range& e) {
63536       {
63537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63538       };
63539     } catch (std::exception& e) {
63540       {
63541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (...) {
63544       {
63545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63546       };
63547     }
63548   }
63549   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63550   return jresult;
63551 }
63552
63553
63554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63555   void * jresult ;
63556   Dali::Toolkit::Control *result = 0 ;
63557
63558   {
63559     try {
63560       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63561     } catch (std::out_of_range& e) {
63562       {
63563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63564       };
63565     } catch (std::exception& e) {
63566       {
63567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63568       };
63569     } catch (...) {
63570       {
63571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63572       };
63573     }
63574   }
63575   jresult = (void *)result;
63576   return jresult;
63577 }
63578
63579
63580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63581   void * jresult ;
63582   Dali::Toolkit::Control *arg1 = 0 ;
63583   Dali::Toolkit::Control *result = 0 ;
63584
63585   arg1 = (Dali::Toolkit::Control *)jarg1;
63586   if (!arg1) {
63587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63588     return 0;
63589   }
63590   {
63591     try {
63592       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63593     } catch (std::out_of_range& e) {
63594       {
63595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63596       };
63597     } catch (std::exception& e) {
63598       {
63599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63600       };
63601     } catch (...) {
63602       {
63603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63604       };
63605     }
63606   }
63607   jresult = (void *)result;
63608   return jresult;
63609 }
63610
63611
63612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63613   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63614
63615   arg1 = (Dali::Toolkit::Control *)jarg1;
63616   {
63617     try {
63618       delete arg1;
63619     } catch (std::out_of_range& e) {
63620       {
63621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63622       };
63623     } catch (std::exception& e) {
63624       {
63625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63630       };
63631     }
63632   }
63633 }
63634
63635
63636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63637   void * jresult ;
63638   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63639   Dali::Toolkit::Control *arg2 = 0 ;
63640   Dali::Toolkit::Control *result = 0 ;
63641
63642   arg1 = (Dali::Toolkit::Control *)jarg1;
63643   arg2 = (Dali::Toolkit::Control *)jarg2;
63644   if (!arg2) {
63645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63646     return 0;
63647   }
63648   {
63649     try {
63650       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63651     } catch (std::out_of_range& e) {
63652       {
63653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63654       };
63655     } catch (std::exception& e) {
63656       {
63657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63658       };
63659     } catch (...) {
63660       {
63661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63662       };
63663     }
63664   }
63665   jresult = (void *)result;
63666   return jresult;
63667 }
63668
63669
63670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63671   void * jresult ;
63672   Dali::BaseHandle arg1 ;
63673   Dali::BaseHandle *argp1 ;
63674   Dali::Toolkit::Control result;
63675
63676   argp1 = (Dali::BaseHandle *)jarg1;
63677   if (!argp1) {
63678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63679     return 0;
63680   }
63681   arg1 = *argp1;
63682   {
63683     try {
63684       result = Dali::Toolkit::Control::DownCast(arg1);
63685     } catch (std::out_of_range& e) {
63686       {
63687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63688       };
63689     } catch (std::exception& e) {
63690       {
63691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (...) {
63694       {
63695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63696       };
63697     }
63698   }
63699   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63700   return jresult;
63701 }
63702
63703
63704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63705   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63706
63707   arg1 = (Dali::Toolkit::Control *)jarg1;
63708   {
63709     try {
63710       (arg1)->SetKeyInputFocus();
63711     } catch (std::out_of_range& e) {
63712       {
63713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63714       };
63715     } catch (std::exception& e) {
63716       {
63717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63718       };
63719     } catch (...) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63722       };
63723     }
63724   }
63725 }
63726
63727
63728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63729   unsigned int jresult ;
63730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63731   bool result;
63732
63733   arg1 = (Dali::Toolkit::Control *)jarg1;
63734   {
63735     try {
63736       result = (bool)(arg1)->HasKeyInputFocus();
63737     } catch (std::out_of_range& e) {
63738       {
63739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (std::exception& e) {
63742       {
63743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (...) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63748       };
63749     }
63750   }
63751   jresult = result;
63752   return jresult;
63753 }
63754
63755
63756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63757   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63758
63759   arg1 = (Dali::Toolkit::Control *)jarg1;
63760   {
63761     try {
63762       (arg1)->ClearKeyInputFocus();
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63770       };
63771     } catch (...) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63774       };
63775     }
63776   }
63777 }
63778
63779
63780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63781   void * jresult ;
63782   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63783   Dali::PinchGestureDetector result;
63784
63785   arg1 = (Dali::Toolkit::Control *)jarg1;
63786   {
63787     try {
63788       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63789     } catch (std::out_of_range& e) {
63790       {
63791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63792       };
63793     } catch (std::exception& e) {
63794       {
63795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63796       };
63797     } catch (...) {
63798       {
63799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63800       };
63801     }
63802   }
63803   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63804   return jresult;
63805 }
63806
63807
63808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63809   void * jresult ;
63810   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63811   Dali::PanGestureDetector result;
63812
63813   arg1 = (Dali::Toolkit::Control *)jarg1;
63814   {
63815     try {
63816       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63817     } catch (std::out_of_range& e) {
63818       {
63819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63820       };
63821     } catch (std::exception& e) {
63822       {
63823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63824       };
63825     } catch (...) {
63826       {
63827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63828       };
63829     }
63830   }
63831   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63832   return jresult;
63833 }
63834
63835
63836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63837   void * jresult ;
63838   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63839   Dali::TapGestureDetector result;
63840
63841   arg1 = (Dali::Toolkit::Control *)jarg1;
63842   {
63843     try {
63844       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63845     } catch (std::out_of_range& e) {
63846       {
63847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63848       };
63849     } catch (std::exception& e) {
63850       {
63851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (...) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63856       };
63857     }
63858   }
63859   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63860   return jresult;
63861 }
63862
63863
63864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63865   void * jresult ;
63866   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63867   Dali::LongPressGestureDetector result;
63868
63869   arg1 = (Dali::Toolkit::Control *)jarg1;
63870   {
63871     try {
63872       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63880       };
63881     } catch (...) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63884       };
63885     }
63886   }
63887   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63888   return jresult;
63889 }
63890
63891
63892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63894   std::string *arg2 = 0 ;
63895
63896   arg1 = (Dali::Toolkit::Control *)jarg1;
63897   if (!jarg2) {
63898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63899     return ;
63900   }
63901   std::string arg2_str(jarg2);
63902   arg2 = &arg2_str;
63903   {
63904     try {
63905       (arg1)->SetStyleName((std::string const &)*arg2);
63906     } catch (std::out_of_range& e) {
63907       {
63908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63909       };
63910     } catch (std::exception& e) {
63911       {
63912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63913       };
63914     } catch (...) {
63915       {
63916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63917       };
63918     }
63919   }
63920
63921   //argout typemap for const std::string&
63922
63923 }
63924
63925
63926 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63927   char * jresult ;
63928   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63929   std::string *result = 0 ;
63930
63931   arg1 = (Dali::Toolkit::Control *)jarg1;
63932   {
63933     try {
63934       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63935     } catch (std::out_of_range& e) {
63936       {
63937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63938       };
63939     } catch (std::exception& e) {
63940       {
63941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63942       };
63943     } catch (...) {
63944       {
63945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63946       };
63947     }
63948   }
63949   jresult = SWIG_csharp_string_callback(result->c_str());
63950   return jresult;
63951 }
63952
63953
63954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63955   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63956   Dali::Vector4 *arg2 = 0 ;
63957
63958   arg1 = (Dali::Toolkit::Control *)jarg1;
63959   arg2 = (Dali::Vector4 *)jarg2;
63960   if (!arg2) {
63961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63962     return ;
63963   }
63964   {
63965     try {
63966       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63967     } catch (std::out_of_range& e) {
63968       {
63969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63970       };
63971     } catch (std::exception& e) {
63972       {
63973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63974       };
63975     } catch (...) {
63976       {
63977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63978       };
63979     }
63980   }
63981 }
63982
63983
63984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63985   void * jresult ;
63986   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63987   Dali::Vector4 result;
63988
63989   arg1 = (Dali::Toolkit::Control *)jarg1;
63990   {
63991     try {
63992       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63993     } catch (std::out_of_range& e) {
63994       {
63995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63996       };
63997     } catch (std::exception& e) {
63998       {
63999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64000       };
64001     } catch (...) {
64002       {
64003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64004       };
64005     }
64006   }
64007   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64008   return jresult;
64009 }
64010
64011
64012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
64013   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64014   Dali::Image arg2 ;
64015   Dali::Image *argp2 ;
64016
64017   arg1 = (Dali::Toolkit::Control *)jarg1;
64018   argp2 = (Dali::Image *)jarg2;
64019   if (!argp2) {
64020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64021     return ;
64022   }
64023   arg2 = *argp2;
64024   {
64025     try {
64026       (arg1)->SetBackgroundImage(arg2);
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64038       };
64039     }
64040   }
64041 }
64042
64043
64044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64045   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64046
64047   arg1 = (Dali::Toolkit::Control *)jarg1;
64048   {
64049     try {
64050       (arg1)->ClearBackground();
64051     } catch (std::out_of_range& e) {
64052       {
64053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64054       };
64055     } catch (std::exception& e) {
64056       {
64057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64058       };
64059     } catch (...) {
64060       {
64061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64062       };
64063     }
64064   }
64065 }
64066
64067
64068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64069   void * jresult ;
64070   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64071   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64072
64073   arg1 = (Dali::Toolkit::Control *)jarg1;
64074   {
64075     try {
64076       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64077     } catch (std::out_of_range& e) {
64078       {
64079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64080       };
64081     } catch (std::exception& e) {
64082       {
64083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64084       };
64085     } catch (...) {
64086       {
64087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64088       };
64089     }
64090   }
64091   jresult = (void *)result;
64092   return jresult;
64093 }
64094
64095
64096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64097   void * jresult ;
64098   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64099   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64100
64101   arg1 = (Dali::Toolkit::Control *)jarg1;
64102   {
64103     try {
64104       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64105     } catch (std::out_of_range& e) {
64106       {
64107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64108       };
64109     } catch (std::exception& e) {
64110       {
64111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64112       };
64113     } catch (...) {
64114       {
64115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64116       };
64117     }
64118   }
64119   jresult = (void *)result;
64120   return jresult;
64121 }
64122
64123
64124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64125   void * jresult ;
64126   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64127   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64128
64129   arg1 = (Dali::Toolkit::Control *)jarg1;
64130   {
64131     try {
64132       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64133     } catch (std::out_of_range& e) {
64134       {
64135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64136       };
64137     } catch (std::exception& e) {
64138       {
64139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64140       };
64141     } catch (...) {
64142       {
64143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64144       };
64145     }
64146   }
64147   jresult = (void *)result;
64148   return jresult;
64149 }
64150
64151
64152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64153   void * jresult ;
64154   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64155   Dali::Toolkit::Control *result = 0 ;
64156
64157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64158   if (!arg1) {
64159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64160     return 0;
64161   }
64162   {
64163     try {
64164       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64165     } catch (std::out_of_range& e) {
64166       {
64167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64168       };
64169     } catch (std::exception& e) {
64170       {
64171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64172       };
64173     } catch (...) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64176       };
64177     }
64178   }
64179   jresult = (void *)result;
64180   return jresult;
64181 }
64182
64183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64184 {
64185   void * jresult;
64186   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64187   arg1 = (Dali::Toolkit::Control *)jarg1;
64188
64189   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64190
64191   Dali::Toolkit::TransitionData *arg2 = 0 ;
64192   Dali::Animation result;
64193
64194   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64195   if (!arg2) {
64196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64197     return 0;
64198   }
64199   {
64200     try {
64201       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64209       };
64210     } catch (...) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64213       };
64214     }
64215   }
64216   jresult = new Dali::Animation((const Dali::Animation &)result);
64217   return jresult;
64218 }
64219
64220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64221   void * jresult ;
64222   Dali::Toolkit::Control *arg1 = 0 ;
64223   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64224
64225   arg1 = (Dali::Toolkit::Control *)jarg1;
64226   if (!arg1) {
64227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64228     return 0;
64229   }
64230   {
64231     try {
64232       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64233     } catch (std::out_of_range& e) {
64234       {
64235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64236       };
64237     } catch (std::exception& e) {
64238       {
64239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64240       };
64241     } catch (...) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64244       };
64245     }
64246   }
64247   jresult = (void *)result;
64248   return jresult;
64249 }
64250
64251
64252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64253   unsigned int jresult ;
64254   Dali::Toolkit::Control *arg1 = 0 ;
64255   bool result;
64256
64257   arg1 = (Dali::Toolkit::Control *)jarg1;
64258   if (!arg1) {
64259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64260     return 0;
64261   }
64262   {
64263     try {
64264       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64272       };
64273     } catch (...) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64276       };
64277     }
64278   }
64279   jresult = result;
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64285   void * jresult ;
64286   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64287
64288   {
64289     try {
64290       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64291     } catch (std::out_of_range& e) {
64292       {
64293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64294       };
64295     } catch (std::exception& e) {
64296       {
64297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64298       };
64299     } catch (...) {
64300       {
64301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64302       };
64303     }
64304   }
64305   jresult = (void *)result;
64306   return jresult;
64307 }
64308
64309
64310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64311   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64312
64313   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64314   {
64315     try {
64316       delete arg1;
64317     } catch (std::out_of_range& e) {
64318       {
64319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64320       };
64321     } catch (std::exception& e) {
64322       {
64323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64328       };
64329     }
64330   }
64331 }
64332
64333
64334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64335   void * jresult ;
64336   Dali::Toolkit::KeyInputFocusManager result;
64337
64338   {
64339     try {
64340       result = Dali::Toolkit::KeyInputFocusManager::Get();
64341     } catch (std::out_of_range& e) {
64342       {
64343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64344       };
64345     } catch (std::exception& e) {
64346       {
64347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64352       };
64353     }
64354   }
64355   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64356   return jresult;
64357 }
64358
64359
64360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64361   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64362   Dali::Toolkit::Control arg2 ;
64363   Dali::Toolkit::Control *argp2 ;
64364
64365   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64366   argp2 = (Dali::Toolkit::Control *)jarg2;
64367   if (!argp2) {
64368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64369     return ;
64370   }
64371   arg2 = *argp2;
64372   {
64373     try {
64374       (arg1)->SetFocus(arg2);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64382       };
64383     } catch (...) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64386       };
64387     }
64388   }
64389 }
64390
64391
64392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64393   void * jresult ;
64394   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64395   Dali::Toolkit::Control result;
64396
64397   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64398   {
64399     try {
64400       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64408       };
64409     } catch (...) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64412       };
64413     }
64414   }
64415   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64421   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64422   Dali::Toolkit::Control arg2 ;
64423   Dali::Toolkit::Control *argp2 ;
64424
64425   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64426   argp2 = (Dali::Toolkit::Control *)jarg2;
64427   if (!argp2) {
64428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64429     return ;
64430   }
64431   arg2 = *argp2;
64432   {
64433     try {
64434       (arg1)->RemoveFocus(arg2);
64435     } catch (std::out_of_range& e) {
64436       {
64437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64438       };
64439     } catch (std::exception& e) {
64440       {
64441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64442       };
64443     } catch (...) {
64444       {
64445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64446       };
64447     }
64448   }
64449 }
64450
64451
64452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64453   void * jresult ;
64454   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64455   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64456
64457   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64458   {
64459     try {
64460       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64461     } catch (std::out_of_range& e) {
64462       {
64463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64464       };
64465     } catch (std::exception& e) {
64466       {
64467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64468       };
64469     } catch (...) {
64470       {
64471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64472       };
64473     }
64474   }
64475   jresult = (void *)result;
64476   return jresult;
64477 }
64478
64479
64480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64481   void * jresult ;
64482   Dali::Toolkit::Alignment::Padding *result = 0 ;
64483
64484   {
64485     try {
64486       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64487     } catch (std::out_of_range& e) {
64488       {
64489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64490       };
64491     } catch (std::exception& e) {
64492       {
64493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64494       };
64495     } catch (...) {
64496       {
64497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64498       };
64499     }
64500   }
64501   jresult = (void *)result;
64502   return jresult;
64503 }
64504
64505
64506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64507   void * jresult ;
64508   float arg1 ;
64509   float arg2 ;
64510   float arg3 ;
64511   float arg4 ;
64512   Dali::Toolkit::Alignment::Padding *result = 0 ;
64513
64514   arg1 = (float)jarg1;
64515   arg2 = (float)jarg2;
64516   arg3 = (float)jarg3;
64517   arg4 = (float)jarg4;
64518   {
64519     try {
64520       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64521     } catch (std::out_of_range& e) {
64522       {
64523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64524       };
64525     } catch (std::exception& e) {
64526       {
64527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64528       };
64529     } catch (...) {
64530       {
64531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64532       };
64533     }
64534   }
64535   jresult = (void *)result;
64536   return jresult;
64537 }
64538
64539
64540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left = arg2;
64547 }
64548
64549
64550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left);
64557   jresult = result;
64558   return jresult;
64559 }
64560
64561
64562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right = arg2;
64569 }
64570
64571
64572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right);
64579   jresult = result;
64580   return jresult;
64581 }
64582
64583
64584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top = arg2;
64591 }
64592
64593
64594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top);
64601   jresult = result;
64602   return jresult;
64603 }
64604
64605
64606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64607   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64608   float arg2 ;
64609
64610   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64611   arg2 = (float)jarg2;
64612   if (arg1) (arg1)->bottom = arg2;
64613 }
64614
64615
64616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64617   float jresult ;
64618   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64619   float result;
64620
64621   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64622   result = (float) ((arg1)->bottom);
64623   jresult = result;
64624   return jresult;
64625 }
64626
64627
64628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64629   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64630
64631   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64632   {
64633     try {
64634       delete arg1;
64635     } catch (std::out_of_range& e) {
64636       {
64637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64638       };
64639     } catch (std::exception& e) {
64640       {
64641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64642       };
64643     } catch (...) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64646       };
64647     }
64648   }
64649 }
64650
64651
64652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64653   void * jresult ;
64654   Dali::Toolkit::Alignment *result = 0 ;
64655
64656   {
64657     try {
64658       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64659     } catch (std::out_of_range& e) {
64660       {
64661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64662       };
64663     } catch (std::exception& e) {
64664       {
64665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64666       };
64667     } catch (...) {
64668       {
64669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64670       };
64671     }
64672   }
64673   jresult = (void *)result;
64674   return jresult;
64675 }
64676
64677
64678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64679   void * jresult ;
64680   Dali::Toolkit::Alignment::Type arg1 ;
64681   Dali::Toolkit::Alignment::Type arg2 ;
64682   Dali::Toolkit::Alignment result;
64683
64684   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64685   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64686   {
64687     try {
64688       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64689     } catch (std::out_of_range& e) {
64690       {
64691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64692       };
64693     } catch (std::exception& e) {
64694       {
64695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (...) {
64698       {
64699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64700       };
64701     }
64702   }
64703   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64704   return jresult;
64705 }
64706
64707
64708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64709   void * jresult ;
64710   Dali::Toolkit::Alignment::Type arg1 ;
64711   Dali::Toolkit::Alignment result;
64712
64713   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64714   {
64715     try {
64716       result = Dali::Toolkit::Alignment::New(arg1);
64717     } catch (std::out_of_range& e) {
64718       {
64719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64720       };
64721     } catch (std::exception& e) {
64722       {
64723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64724       };
64725     } catch (...) {
64726       {
64727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64728       };
64729     }
64730   }
64731   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64732   return jresult;
64733 }
64734
64735
64736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64737   void * jresult ;
64738   Dali::Toolkit::Alignment result;
64739
64740   {
64741     try {
64742       result = Dali::Toolkit::Alignment::New();
64743     } catch (std::out_of_range& e) {
64744       {
64745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64746       };
64747     } catch (std::exception& e) {
64748       {
64749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64750       };
64751     } catch (...) {
64752       {
64753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64754       };
64755     }
64756   }
64757   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64758   return jresult;
64759 }
64760
64761
64762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64763   void * jresult ;
64764   Dali::Toolkit::Alignment *arg1 = 0 ;
64765   Dali::Toolkit::Alignment *result = 0 ;
64766
64767   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64768   if (!arg1) {
64769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64770     return 0;
64771   }
64772   {
64773     try {
64774       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64775     } catch (std::out_of_range& e) {
64776       {
64777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64778       };
64779     } catch (std::exception& e) {
64780       {
64781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64782       };
64783     } catch (...) {
64784       {
64785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64786       };
64787     }
64788   }
64789   jresult = (void *)result;
64790   return jresult;
64791 }
64792
64793
64794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64795   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64796
64797   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64798   {
64799     try {
64800       delete arg1;
64801     } catch (std::out_of_range& e) {
64802       {
64803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64804       };
64805     } catch (std::exception& e) {
64806       {
64807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64808       };
64809     } catch (...) {
64810       {
64811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64812       };
64813     }
64814   }
64815 }
64816
64817
64818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64819   void * jresult ;
64820   Dali::BaseHandle arg1 ;
64821   Dali::BaseHandle *argp1 ;
64822   Dali::Toolkit::Alignment result;
64823
64824   argp1 = (Dali::BaseHandle *)jarg1;
64825   if (!argp1) {
64826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64827     return 0;
64828   }
64829   arg1 = *argp1;
64830   {
64831     try {
64832       result = Dali::Toolkit::Alignment::DownCast(arg1);
64833     } catch (std::out_of_range& e) {
64834       {
64835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64836       };
64837     } catch (std::exception& e) {
64838       {
64839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64840       };
64841     } catch (...) {
64842       {
64843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64844       };
64845     }
64846   }
64847   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64848   return jresult;
64849 }
64850
64851
64852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64853   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64854   Dali::Toolkit::Alignment::Type arg2 ;
64855
64856   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64857   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64858   {
64859     try {
64860       (arg1)->SetAlignmentType(arg2);
64861     } catch (std::out_of_range& e) {
64862       {
64863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64864       };
64865     } catch (std::exception& e) {
64866       {
64867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64868       };
64869     } catch (...) {
64870       {
64871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64872       };
64873     }
64874   }
64875 }
64876
64877
64878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64879   int jresult ;
64880   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64881   Dali::Toolkit::Alignment::Type result;
64882
64883   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64884   {
64885     try {
64886       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64887     } catch (std::out_of_range& e) {
64888       {
64889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64890       };
64891     } catch (std::exception& e) {
64892       {
64893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64894       };
64895     } catch (...) {
64896       {
64897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64898       };
64899     }
64900   }
64901   jresult = (int)result;
64902   return jresult;
64903 }
64904
64905
64906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64907   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64908   Dali::Toolkit::Alignment::Scaling arg2 ;
64909
64910   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64911   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64912   {
64913     try {
64914       (arg1)->SetScaling(arg2);
64915     } catch (std::out_of_range& e) {
64916       {
64917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64918       };
64919     } catch (std::exception& e) {
64920       {
64921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64922       };
64923     } catch (...) {
64924       {
64925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64926       };
64927     }
64928   }
64929 }
64930
64931
64932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64933   int jresult ;
64934   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64935   Dali::Toolkit::Alignment::Scaling result;
64936
64937   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64938   {
64939     try {
64940       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64941     } catch (std::out_of_range& e) {
64942       {
64943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64944       };
64945     } catch (std::exception& e) {
64946       {
64947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64948       };
64949     } catch (...) {
64950       {
64951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64952       };
64953     }
64954   }
64955   jresult = (int)result;
64956   return jresult;
64957 }
64958
64959
64960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64961   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64962   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64963
64964   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64965   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64966   if (!arg2) {
64967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64968     return ;
64969   }
64970   {
64971     try {
64972       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64973     } catch (std::out_of_range& e) {
64974       {
64975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64976       };
64977     } catch (std::exception& e) {
64978       {
64979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64980       };
64981     } catch (...) {
64982       {
64983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64984       };
64985     }
64986   }
64987 }
64988
64989
64990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64991   void * jresult ;
64992   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64993   Dali::Toolkit::Alignment::Padding *result = 0 ;
64994
64995   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64996   {
64997     try {
64998       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64999     } catch (std::out_of_range& e) {
65000       {
65001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65002       };
65003     } catch (std::exception& e) {
65004       {
65005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (...) {
65008       {
65009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65010       };
65011     }
65012   }
65013   jresult = (void *)result;
65014   return jresult;
65015 }
65016
65017
65018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
65019   void * jresult ;
65020   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65021   Dali::Toolkit::Alignment *arg2 = 0 ;
65022   Dali::Toolkit::Alignment *result = 0 ;
65023
65024   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65025   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65026   if (!arg2) {
65027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65028     return 0;
65029   }
65030   {
65031     try {
65032       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65033     } catch (std::out_of_range& e) {
65034       {
65035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65036       };
65037     } catch (std::exception& e) {
65038       {
65039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65040       };
65041     } catch (...) {
65042       {
65043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65044       };
65045     }
65046   }
65047   jresult = (void *)result;
65048   return jresult;
65049 }
65050
65051
65052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65053   int jresult ;
65054   int result;
65055
65056   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65057   jresult = (int)result;
65058   return jresult;
65059 }
65060
65061
65062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65063   int jresult ;
65064   int result;
65065
65066   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65067   jresult = (int)result;
65068   return jresult;
65069 }
65070
65071
65072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65073   int jresult ;
65074   int result;
65075
65076   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65077   jresult = (int)result;
65078   return jresult;
65079 }
65080
65081
65082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65083   int jresult ;
65084   int result;
65085
65086   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65087   jresult = (int)result;
65088   return jresult;
65089 }
65090
65091
65092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65093   int jresult ;
65094   int result;
65095
65096   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65097   jresult = (int)result;
65098   return jresult;
65099 }
65100
65101
65102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65103   int jresult ;
65104   int result;
65105
65106   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65107   jresult = (int)result;
65108   return jresult;
65109 }
65110
65111
65112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
65113   int jresult ;
65114   int result;
65115
65116   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
65117   jresult = (int)result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
65123   int jresult ;
65124   int result;
65125
65126   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
65127   jresult = (int)result;
65128   return jresult;
65129 }
65130
65131
65132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65133   int jresult ;
65134   int result;
65135
65136   result = (int)Dali::Toolkit::Button::Property::LABEL;
65137   jresult = (int)result;
65138   return jresult;
65139 }
65140
65141
65142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65143   int jresult ;
65144   int result;
65145
65146   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65147   jresult = (int)result;
65148   return jresult;
65149 }
65150
65151
65152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65153   void * jresult ;
65154   Dali::Toolkit::Button::Property *result = 0 ;
65155
65156   {
65157     try {
65158       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65159     } catch (std::out_of_range& e) {
65160       {
65161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (std::exception& e) {
65164       {
65165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65170       };
65171     }
65172   }
65173   jresult = (void *)result;
65174   return jresult;
65175 }
65176
65177
65178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65179   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65180
65181   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65182   {
65183     try {
65184       delete arg1;
65185     } catch (std::out_of_range& e) {
65186       {
65187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65188       };
65189     } catch (std::exception& e) {
65190       {
65191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65192       };
65193     } catch (...) {
65194       {
65195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65196       };
65197     }
65198   }
65199 }
65200
65201
65202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65203   void * jresult ;
65204   Dali::Toolkit::Button *result = 0 ;
65205
65206   {
65207     try {
65208       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65209     } catch (std::out_of_range& e) {
65210       {
65211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65212       };
65213     } catch (std::exception& e) {
65214       {
65215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65216       };
65217     } catch (...) {
65218       {
65219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65220       };
65221     }
65222   }
65223   jresult = (void *)result;
65224   return jresult;
65225 }
65226
65227
65228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65229   void * jresult ;
65230   Dali::Toolkit::Button *arg1 = 0 ;
65231   Dali::Toolkit::Button *result = 0 ;
65232
65233   arg1 = (Dali::Toolkit::Button *)jarg1;
65234   if (!arg1) {
65235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65236     return 0;
65237   }
65238   {
65239     try {
65240       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65241     } catch (std::out_of_range& e) {
65242       {
65243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65244       };
65245     } catch (std::exception& e) {
65246       {
65247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65248       };
65249     } catch (...) {
65250       {
65251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65252       };
65253     }
65254   }
65255   jresult = (void *)result;
65256   return jresult;
65257 }
65258
65259
65260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65261   void * jresult ;
65262   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65263   Dali::Toolkit::Button *arg2 = 0 ;
65264   Dali::Toolkit::Button *result = 0 ;
65265
65266   arg1 = (Dali::Toolkit::Button *)jarg1;
65267   arg2 = (Dali::Toolkit::Button *)jarg2;
65268   if (!arg2) {
65269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65270     return 0;
65271   }
65272   {
65273     try {
65274       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65275     } catch (std::out_of_range& e) {
65276       {
65277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65278       };
65279     } catch (std::exception& e) {
65280       {
65281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65282       };
65283     } catch (...) {
65284       {
65285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65286       };
65287     }
65288   }
65289   jresult = (void *)result;
65290   return jresult;
65291 }
65292
65293
65294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65295   void * jresult ;
65296   Dali::BaseHandle arg1 ;
65297   Dali::BaseHandle *argp1 ;
65298   Dali::Toolkit::Button result;
65299
65300   argp1 = (Dali::BaseHandle *)jarg1;
65301   if (!argp1) {
65302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65303     return 0;
65304   }
65305   arg1 = *argp1;
65306   {
65307     try {
65308       result = Dali::Toolkit::Button::DownCast(arg1);
65309     } catch (std::out_of_range& e) {
65310       {
65311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (std::exception& e) {
65314       {
65315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65316       };
65317     } catch (...) {
65318       {
65319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65320       };
65321     }
65322   }
65323   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65324   return jresult;
65325 }
65326
65327
65328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65329   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65330
65331   arg1 = (Dali::Toolkit::Button *)jarg1;
65332   {
65333     try {
65334       delete arg1;
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65342       };
65343     } catch (...) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65346       };
65347     }
65348   }
65349 }
65350
65351
65352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65353   unsigned int jresult ;
65354   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65355   bool result;
65356
65357   arg1 = (Dali::Toolkit::Button *)jarg1;
65358   {
65359     try {
65360       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65361     } catch (std::out_of_range& e) {
65362       {
65363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65364       };
65365     } catch (std::exception& e) {
65366       {
65367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (...) {
65370       {
65371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65372       };
65373     }
65374   }
65375   jresult = result;
65376   return jresult;
65377 }
65378
65379
65380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65381   unsigned int jresult ;
65382   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65383   bool result;
65384
65385   arg1 = (Dali::Toolkit::Button *)jarg1;
65386   {
65387     try {
65388       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65389     } catch (std::out_of_range& e) {
65390       {
65391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (std::exception& e) {
65394       {
65395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (...) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65400       };
65401     }
65402   }
65403   jresult = result;
65404   return jresult;
65405 }
65406
65407
65408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65409   float jresult ;
65410   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65411   float result;
65412
65413   arg1 = (Dali::Toolkit::Button *)jarg1;
65414   {
65415     try {
65416       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65417     } catch (std::out_of_range& e) {
65418       {
65419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65420       };
65421     } catch (std::exception& e) {
65422       {
65423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65424       };
65425     } catch (...) {
65426       {
65427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65428       };
65429     }
65430   }
65431   jresult = result;
65432   return jresult;
65433 }
65434
65435
65436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65437   float jresult ;
65438   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65439   float result;
65440
65441   arg1 = (Dali::Toolkit::Button *)jarg1;
65442   {
65443     try {
65444       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65445     } catch (std::out_of_range& e) {
65446       {
65447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65448       };
65449     } catch (std::exception& e) {
65450       {
65451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65452       };
65453     } catch (...) {
65454       {
65455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65456       };
65457     }
65458   }
65459   jresult = result;
65460   return jresult;
65461 }
65462
65463
65464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65465   unsigned int jresult ;
65466   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65467   bool result;
65468
65469   arg1 = (Dali::Toolkit::Button *)jarg1;
65470   {
65471     try {
65472       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65473     } catch (std::out_of_range& e) {
65474       {
65475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65476       };
65477     } catch (std::exception& e) {
65478       {
65479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65480       };
65481     } catch (...) {
65482       {
65483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65484       };
65485     }
65486   }
65487   jresult = result;
65488   return jresult;
65489 }
65490
65491
65492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65493   unsigned int jresult ;
65494   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65495   bool result;
65496
65497   arg1 = (Dali::Toolkit::Button *)jarg1;
65498   {
65499     try {
65500       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65501     } catch (std::out_of_range& e) {
65502       {
65503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65504       };
65505     } catch (std::exception& e) {
65506       {
65507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65508       };
65509     } catch (...) {
65510       {
65511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65512       };
65513     }
65514   }
65515   jresult = result;
65516   return jresult;
65517 }
65518
65519
65520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65521   float jresult ;
65522   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65523   float result;
65524
65525   arg1 = (Dali::Toolkit::Button *)jarg1;
65526   {
65527     try {
65528       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65529     } catch (std::out_of_range& e) {
65530       {
65531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65532       };
65533     } catch (std::exception& e) {
65534       {
65535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65536       };
65537     } catch (...) {
65538       {
65539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65540       };
65541     }
65542   }
65543   jresult = result;
65544   return jresult;
65545 }
65546
65547
65548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65549   char * jresult ;
65550   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65551   std::string result;
65552
65553   arg1 = (Dali::Toolkit::Button *)jarg1;
65554   {
65555     try {
65556       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65557     } catch (std::out_of_range& e) {
65558       {
65559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65560       };
65561     } catch (std::exception& e) {
65562       {
65563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65564       };
65565     } catch (...) {
65566       {
65567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65568       };
65569     }
65570   }
65571   jresult = SWIG_csharp_string_callback((&result)->c_str());
65572   return jresult;
65573 }
65574
65575
65576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65577   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65578   Dali::Actor arg2 ;
65579   Dali::Actor *argp2 ;
65580
65581   arg1 = (Dali::Toolkit::Button *)jarg1;
65582   argp2 = (Dali::Actor *)jarg2;
65583   if (!argp2) {
65584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65585     return ;
65586   }
65587   arg2 = *argp2;
65588   {
65589     try {
65590       (arg1)->SetLabel(arg2);
65591     } catch (std::out_of_range& e) {
65592       {
65593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65594       };
65595     } catch (std::exception& e) {
65596       {
65597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65598       };
65599     } catch (...) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65602       };
65603     }
65604   }
65605 }
65606
65607
65608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65609   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65610   Dali::Image arg2 ;
65611   Dali::Image *argp2 ;
65612
65613   arg1 = (Dali::Toolkit::Button *)jarg1;
65614   argp2 = (Dali::Image *)jarg2;
65615   if (!argp2) {
65616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65617     return ;
65618   }
65619   arg2 = *argp2;
65620   {
65621     try {
65622       (arg1)->SetButtonImage(arg2);
65623     } catch (std::out_of_range& e) {
65624       {
65625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65626       };
65627     } catch (std::exception& e) {
65628       {
65629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65630       };
65631     } catch (...) {
65632       {
65633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65634       };
65635     }
65636   }
65637 }
65638
65639
65640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65641   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65642   Dali::Image arg2 ;
65643   Dali::Image *argp2 ;
65644
65645   arg1 = (Dali::Toolkit::Button *)jarg1;
65646   argp2 = (Dali::Image *)jarg2;
65647   if (!argp2) {
65648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65649     return ;
65650   }
65651   arg2 = *argp2;
65652   {
65653     try {
65654       (arg1)->SetSelectedImage(arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (...) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65666       };
65667     }
65668   }
65669 }
65670
65671
65672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65673   void * jresult ;
65674   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65675   Dali::Actor result;
65676
65677   arg1 = (Dali::Toolkit::Button *)jarg1;
65678   {
65679     try {
65680       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65681     } catch (std::out_of_range& e) {
65682       {
65683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65684       };
65685     } catch (std::exception& e) {
65686       {
65687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65688       };
65689     } catch (...) {
65690       {
65691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65692       };
65693     }
65694   }
65695   jresult = new Dali::Actor((const Dali::Actor &)result);
65696   return jresult;
65697 }
65698
65699
65700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65701   void * jresult ;
65702   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65703   Dali::Actor result;
65704
65705   arg1 = (Dali::Toolkit::Button *)jarg1;
65706   {
65707     try {
65708       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65709     } catch (std::out_of_range& e) {
65710       {
65711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65712       };
65713     } catch (std::exception& e) {
65714       {
65715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65716       };
65717     } catch (...) {
65718       {
65719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65720       };
65721     }
65722   }
65723   jresult = new Dali::Actor((const Dali::Actor &)result);
65724   return jresult;
65725 }
65726
65727
65728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65729   void * jresult ;
65730   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65731   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65732
65733   arg1 = (Dali::Toolkit::Button *)jarg1;
65734   {
65735     try {
65736       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65737     } catch (std::out_of_range& e) {
65738       {
65739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65740       };
65741     } catch (std::exception& e) {
65742       {
65743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (...) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65748       };
65749     }
65750   }
65751   jresult = (void *)result;
65752   return jresult;
65753 }
65754
65755
65756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65757   void * jresult ;
65758   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65759   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65760
65761   arg1 = (Dali::Toolkit::Button *)jarg1;
65762   {
65763     try {
65764       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65765     } catch (std::out_of_range& e) {
65766       {
65767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65768       };
65769     } catch (std::exception& e) {
65770       {
65771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65772       };
65773     } catch (...) {
65774       {
65775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65776       };
65777     }
65778   }
65779   jresult = (void *)result;
65780   return jresult;
65781 }
65782
65783
65784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65785   void * jresult ;
65786   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65787   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65788
65789   arg1 = (Dali::Toolkit::Button *)jarg1;
65790   {
65791     try {
65792       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65793     } catch (std::out_of_range& e) {
65794       {
65795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65796       };
65797     } catch (std::exception& e) {
65798       {
65799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65800       };
65801     } catch (...) {
65802       {
65803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65804       };
65805     }
65806   }
65807   jresult = (void *)result;
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65813   void * jresult ;
65814   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65815   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65816
65817   arg1 = (Dali::Toolkit::Button *)jarg1;
65818   {
65819     try {
65820       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65821     } catch (std::out_of_range& e) {
65822       {
65823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65824       };
65825     } catch (std::exception& e) {
65826       {
65827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65828       };
65829     } catch (...) {
65830       {
65831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65832       };
65833     }
65834   }
65835   jresult = (void *)result;
65836   return jresult;
65837 }
65838
65839
65840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65841   void * jresult ;
65842   Dali::Toolkit::CheckBoxButton *result = 0 ;
65843
65844   {
65845     try {
65846       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65847     } catch (std::out_of_range& e) {
65848       {
65849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65850       };
65851     } catch (std::exception& e) {
65852       {
65853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65854       };
65855     } catch (...) {
65856       {
65857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65858       };
65859     }
65860   }
65861   jresult = (void *)result;
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65867   void * jresult ;
65868   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65869   Dali::Toolkit::CheckBoxButton *result = 0 ;
65870
65871   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65872   if (!arg1) {
65873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65874     return 0;
65875   }
65876   {
65877     try {
65878       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65879     } catch (std::out_of_range& e) {
65880       {
65881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (std::exception& e) {
65884       {
65885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65886       };
65887     } catch (...) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65890       };
65891     }
65892   }
65893   jresult = (void *)result;
65894   return jresult;
65895 }
65896
65897
65898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65899   void * jresult ;
65900   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65901   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65902   Dali::Toolkit::CheckBoxButton *result = 0 ;
65903
65904   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65905   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65906   if (!arg2) {
65907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65908     return 0;
65909   }
65910   {
65911     try {
65912       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65913     } catch (std::out_of_range& e) {
65914       {
65915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65916       };
65917     } catch (std::exception& e) {
65918       {
65919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65920       };
65921     } catch (...) {
65922       {
65923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65924       };
65925     }
65926   }
65927   jresult = (void *)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65933   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65934
65935   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65936   {
65937     try {
65938       delete arg1;
65939     } catch (std::out_of_range& e) {
65940       {
65941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65942       };
65943     } catch (std::exception& e) {
65944       {
65945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65946       };
65947     } catch (...) {
65948       {
65949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65950       };
65951     }
65952   }
65953 }
65954
65955
65956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65957   void * jresult ;
65958   Dali::Toolkit::CheckBoxButton result;
65959
65960   {
65961     try {
65962       result = Dali::Toolkit::CheckBoxButton::New();
65963     } catch (std::out_of_range& e) {
65964       {
65965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65966       };
65967     } catch (std::exception& e) {
65968       {
65969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65970       };
65971     } catch (...) {
65972       {
65973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65974       };
65975     }
65976   }
65977   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65978   return jresult;
65979 }
65980
65981
65982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65983   void * jresult ;
65984   Dali::BaseHandle arg1 ;
65985   Dali::BaseHandle *argp1 ;
65986   Dali::Toolkit::CheckBoxButton result;
65987
65988   argp1 = (Dali::BaseHandle *)jarg1;
65989   if (!argp1) {
65990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65991     return 0;
65992   }
65993   arg1 = *argp1;
65994   {
65995     try {
65996       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65997     } catch (std::out_of_range& e) {
65998       {
65999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66000       };
66001     } catch (std::exception& e) {
66002       {
66003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66004       };
66005     } catch (...) {
66006       {
66007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66008       };
66009     }
66010   }
66011   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66012   return jresult;
66013 }
66014
66015
66016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
66017   int jresult ;
66018   int result;
66019
66020   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
66021   jresult = (int)result;
66022   return jresult;
66023 }
66024
66025
66026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
66027   int jresult ;
66028   int result;
66029
66030   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
66031   jresult = (int)result;
66032   return jresult;
66033 }
66034
66035
66036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66037   int jresult ;
66038   int result;
66039
66040   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
66041   jresult = (int)result;
66042   return jresult;
66043 }
66044
66045
66046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
66047   int jresult ;
66048   int result;
66049
66050   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
66051   jresult = (int)result;
66052   return jresult;
66053 }
66054
66055
66056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
66057   int jresult ;
66058   int result;
66059
66060   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66061   jresult = (int)result;
66062   return jresult;
66063 }
66064
66065
66066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66067   void * jresult ;
66068   Dali::Toolkit::PushButton::Property *result = 0 ;
66069
66070   {
66071     try {
66072       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
66073     } catch (std::out_of_range& e) {
66074       {
66075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (std::exception& e) {
66078       {
66079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66080       };
66081     } catch (...) {
66082       {
66083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66084       };
66085     }
66086   }
66087   jresult = (void *)result;
66088   return jresult;
66089 }
66090
66091
66092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
66093   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66094
66095   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
66096   {
66097     try {
66098       delete arg1;
66099     } catch (std::out_of_range& e) {
66100       {
66101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66102       };
66103     } catch (std::exception& e) {
66104       {
66105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66106       };
66107     } catch (...) {
66108       {
66109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66110       };
66111     }
66112   }
66113 }
66114
66115
66116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
66117   void * jresult ;
66118   Dali::Toolkit::PushButton *result = 0 ;
66119
66120   {
66121     try {
66122       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66130       };
66131     } catch (...) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66134       };
66135     }
66136   }
66137   jresult = (void *)result;
66138   return jresult;
66139 }
66140
66141
66142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66143   void * jresult ;
66144   Dali::Toolkit::PushButton *arg1 = 0 ;
66145   Dali::Toolkit::PushButton *result = 0 ;
66146
66147   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66148   if (!arg1) {
66149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66150     return 0;
66151   }
66152   {
66153     try {
66154       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66155     } catch (std::out_of_range& e) {
66156       {
66157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (std::exception& e) {
66160       {
66161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66166       };
66167     }
66168   }
66169   jresult = (void *)result;
66170   return jresult;
66171 }
66172
66173
66174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66175   void * jresult ;
66176   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66177   Dali::Toolkit::PushButton *arg2 = 0 ;
66178   Dali::Toolkit::PushButton *result = 0 ;
66179
66180   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66181   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66182   if (!arg2) {
66183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66184     return 0;
66185   }
66186   {
66187     try {
66188       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66189     } catch (std::out_of_range& e) {
66190       {
66191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66192       };
66193     } catch (std::exception& e) {
66194       {
66195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66196       };
66197     } catch (...) {
66198       {
66199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66200       };
66201     }
66202   }
66203   jresult = (void *)result;
66204   return jresult;
66205 }
66206
66207
66208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66209   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66210
66211   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66212   {
66213     try {
66214       delete arg1;
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66222       };
66223     } catch (...) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66226       };
66227     }
66228   }
66229 }
66230
66231
66232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66233   void * jresult ;
66234   Dali::Toolkit::PushButton result;
66235
66236   {
66237     try {
66238       result = Dali::Toolkit::PushButton::New();
66239     } catch (std::out_of_range& e) {
66240       {
66241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66242       };
66243     } catch (std::exception& e) {
66244       {
66245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66250       };
66251     }
66252   }
66253   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66254   return jresult;
66255 }
66256
66257
66258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66259   void * jresult ;
66260   Dali::BaseHandle arg1 ;
66261   Dali::BaseHandle *argp1 ;
66262   Dali::Toolkit::PushButton result;
66263
66264   argp1 = (Dali::BaseHandle *)jarg1;
66265   if (!argp1) {
66266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66267     return 0;
66268   }
66269   arg1 = *argp1;
66270   {
66271     try {
66272       result = Dali::Toolkit::PushButton::DownCast(arg1);
66273     } catch (std::out_of_range& e) {
66274       {
66275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66276       };
66277     } catch (std::exception& e) {
66278       {
66279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (...) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66284       };
66285     }
66286   }
66287   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66288   return jresult;
66289 }
66290
66291
66292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66293   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66294   Dali::Image arg2 ;
66295   Dali::Image *argp2 ;
66296
66297   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66298   argp2 = (Dali::Image *)jarg2;
66299   if (!argp2) {
66300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66301     return ;
66302   }
66303   arg2 = *argp2;
66304   {
66305     try {
66306       (arg1)->SetButtonImage(arg2);
66307     } catch (std::out_of_range& e) {
66308       {
66309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66310       };
66311     } catch (std::exception& e) {
66312       {
66313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66314       };
66315     } catch (...) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66318       };
66319     }
66320   }
66321 }
66322
66323
66324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66325   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66326   Dali::Actor arg2 ;
66327   Dali::Actor *argp2 ;
66328
66329   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66330   argp2 = (Dali::Actor *)jarg2;
66331   if (!argp2) {
66332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66333     return ;
66334   }
66335   arg2 = *argp2;
66336   {
66337     try {
66338       (arg1)->SetButtonImage(arg2);
66339     } catch (std::out_of_range& e) {
66340       {
66341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66342       };
66343     } catch (std::exception& e) {
66344       {
66345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66346       };
66347     } catch (...) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66350       };
66351     }
66352   }
66353 }
66354
66355
66356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66357   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66358   Dali::Actor arg2 ;
66359   Dali::Actor *argp2 ;
66360
66361   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66362   argp2 = (Dali::Actor *)jarg2;
66363   if (!argp2) {
66364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66365     return ;
66366   }
66367   arg2 = *argp2;
66368   {
66369     try {
66370       (arg1)->SetBackgroundImage(arg2);
66371     } catch (std::out_of_range& e) {
66372       {
66373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66374       };
66375     } catch (std::exception& e) {
66376       {
66377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66378       };
66379     } catch (...) {
66380       {
66381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66382       };
66383     }
66384   }
66385 }
66386
66387
66388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66389   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66390   Dali::Image arg2 ;
66391   Dali::Image *argp2 ;
66392
66393   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66394   argp2 = (Dali::Image *)jarg2;
66395   if (!argp2) {
66396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66397     return ;
66398   }
66399   arg2 = *argp2;
66400   {
66401     try {
66402       (arg1)->SetSelectedImage(arg2);
66403     } catch (std::out_of_range& e) {
66404       {
66405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66406       };
66407     } catch (std::exception& e) {
66408       {
66409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66414       };
66415     }
66416   }
66417 }
66418
66419
66420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66421   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66422   Dali::Actor arg2 ;
66423   Dali::Actor *argp2 ;
66424
66425   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66426   argp2 = (Dali::Actor *)jarg2;
66427   if (!argp2) {
66428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66429     return ;
66430   }
66431   arg2 = *argp2;
66432   {
66433     try {
66434       (arg1)->SetSelectedImage(arg2);
66435     } catch (std::out_of_range& e) {
66436       {
66437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66438       };
66439     } catch (std::exception& e) {
66440       {
66441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66442       };
66443     } catch (...) {
66444       {
66445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66446       };
66447     }
66448   }
66449 }
66450
66451
66452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66453   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66454   Dali::Actor arg2 ;
66455   Dali::Actor *argp2 ;
66456
66457   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66458   argp2 = (Dali::Actor *)jarg2;
66459   if (!argp2) {
66460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66461     return ;
66462   }
66463   arg2 = *argp2;
66464   {
66465     try {
66466       (arg1)->SetSelectedBackgroundImage(arg2);
66467     } catch (std::out_of_range& e) {
66468       {
66469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66470       };
66471     } catch (std::exception& e) {
66472       {
66473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66474       };
66475     } catch (...) {
66476       {
66477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66478       };
66479     }
66480   }
66481 }
66482
66483
66484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66485   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66486   Dali::Actor arg2 ;
66487   Dali::Actor *argp2 ;
66488
66489   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66490   argp2 = (Dali::Actor *)jarg2;
66491   if (!argp2) {
66492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66493     return ;
66494   }
66495   arg2 = *argp2;
66496   {
66497     try {
66498       (arg1)->SetDisabledBackgroundImage(arg2);
66499     } catch (std::out_of_range& e) {
66500       {
66501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66502       };
66503     } catch (std::exception& e) {
66504       {
66505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66506       };
66507     } catch (...) {
66508       {
66509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66510       };
66511     }
66512   }
66513 }
66514
66515
66516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66517   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66518   Dali::Actor arg2 ;
66519   Dali::Actor *argp2 ;
66520
66521   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66522   argp2 = (Dali::Actor *)jarg2;
66523   if (!argp2) {
66524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66525     return ;
66526   }
66527   arg2 = *argp2;
66528   {
66529     try {
66530       (arg1)->SetDisabledImage(arg2);
66531     } catch (std::out_of_range& e) {
66532       {
66533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66534       };
66535     } catch (std::exception& e) {
66536       {
66537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66538       };
66539     } catch (...) {
66540       {
66541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66542       };
66543     }
66544   }
66545 }
66546
66547
66548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66549   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66550   Dali::Actor arg2 ;
66551   Dali::Actor *argp2 ;
66552
66553   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66554   argp2 = (Dali::Actor *)jarg2;
66555   if (!argp2) {
66556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66557     return ;
66558   }
66559   arg2 = *argp2;
66560   {
66561     try {
66562       (arg1)->SetDisabledSelectedImage(arg2);
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66570       };
66571     } catch (...) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66574       };
66575     }
66576   }
66577 }
66578
66579
66580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66581   void * jresult ;
66582   Dali::Toolkit::RadioButton *result = 0 ;
66583
66584   {
66585     try {
66586       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66587     } catch (std::out_of_range& e) {
66588       {
66589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66590       };
66591     } catch (std::exception& e) {
66592       {
66593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66594       };
66595     } catch (...) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66598       };
66599     }
66600   }
66601   jresult = (void *)result;
66602   return jresult;
66603 }
66604
66605
66606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66607   void * jresult ;
66608   Dali::Toolkit::RadioButton *arg1 = 0 ;
66609   Dali::Toolkit::RadioButton *result = 0 ;
66610
66611   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66612   if (!arg1) {
66613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66614     return 0;
66615   }
66616   {
66617     try {
66618       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66626       };
66627     } catch (...) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66630       };
66631     }
66632   }
66633   jresult = (void *)result;
66634   return jresult;
66635 }
66636
66637
66638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66639   void * jresult ;
66640   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66641   Dali::Toolkit::RadioButton *arg2 = 0 ;
66642   Dali::Toolkit::RadioButton *result = 0 ;
66643
66644   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66645   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66646   if (!arg2) {
66647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66648     return 0;
66649   }
66650   {
66651     try {
66652       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66653     } catch (std::out_of_range& e) {
66654       {
66655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66656       };
66657     } catch (std::exception& e) {
66658       {
66659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66660       };
66661     } catch (...) {
66662       {
66663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66664       };
66665     }
66666   }
66667   jresult = (void *)result;
66668   return jresult;
66669 }
66670
66671
66672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66673   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66674
66675   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66676   {
66677     try {
66678       delete arg1;
66679     } catch (std::out_of_range& e) {
66680       {
66681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66682       };
66683     } catch (std::exception& e) {
66684       {
66685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66686       };
66687     } catch (...) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66690       };
66691     }
66692   }
66693 }
66694
66695
66696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66697   void * jresult ;
66698   Dali::Toolkit::RadioButton result;
66699
66700   {
66701     try {
66702       result = Dali::Toolkit::RadioButton::New();
66703     } catch (std::out_of_range& e) {
66704       {
66705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66706       };
66707     } catch (std::exception& e) {
66708       {
66709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66710       };
66711     } catch (...) {
66712       {
66713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66714       };
66715     }
66716   }
66717   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66718   return jresult;
66719 }
66720
66721
66722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66723   void * jresult ;
66724   std::string *arg1 = 0 ;
66725   Dali::Toolkit::RadioButton result;
66726
66727   if (!jarg1) {
66728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66729     return 0;
66730   }
66731   std::string arg1_str(jarg1);
66732   arg1 = &arg1_str;
66733   {
66734     try {
66735       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66736     } catch (std::out_of_range& e) {
66737       {
66738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66739       };
66740     } catch (std::exception& e) {
66741       {
66742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66743       };
66744     } catch (...) {
66745       {
66746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66747       };
66748     }
66749   }
66750   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66751
66752   //argout typemap for const std::string&
66753
66754   return jresult;
66755 }
66756
66757
66758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66759   void * jresult ;
66760   Dali::BaseHandle arg1 ;
66761   Dali::BaseHandle *argp1 ;
66762   Dali::Toolkit::RadioButton result;
66763
66764   argp1 = (Dali::BaseHandle *)jarg1;
66765   if (!argp1) {
66766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66767     return 0;
66768   }
66769   arg1 = *argp1;
66770   {
66771     try {
66772       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66773     } catch (std::out_of_range& e) {
66774       {
66775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66776       };
66777     } catch (std::exception& e) {
66778       {
66779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66780       };
66781     } catch (...) {
66782       {
66783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66784       };
66785     }
66786   }
66787   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66788   return jresult;
66789 }
66790
66791
66792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66793   int jresult ;
66794   int result;
66795
66796   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66797   jresult = (int)result;
66798   return jresult;
66799 }
66800
66801
66802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66803   int jresult ;
66804   int result;
66805
66806   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66807   jresult = (int)result;
66808   return jresult;
66809 }
66810
66811
66812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66813   int jresult ;
66814   int result;
66815
66816   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66817   jresult = (int)result;
66818   return jresult;
66819 }
66820
66821
66822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66823   int jresult ;
66824   int result;
66825
66826   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66827   jresult = (int)result;
66828   return jresult;
66829 }
66830
66831
66832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66833   int jresult ;
66834   int result;
66835
66836   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66837   jresult = (int)result;
66838   return jresult;
66839 }
66840
66841
66842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66843   int jresult ;
66844   int result;
66845
66846   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66847   jresult = (int)result;
66848   return jresult;
66849 }
66850
66851
66852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66853   void * jresult ;
66854   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66855
66856   {
66857     try {
66858       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66859     } catch (std::out_of_range& e) {
66860       {
66861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66862       };
66863     } catch (std::exception& e) {
66864       {
66865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66866       };
66867     } catch (...) {
66868       {
66869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66870       };
66871     }
66872   }
66873   jresult = (void *)result;
66874   return jresult;
66875 }
66876
66877
66878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66879   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66880
66881   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66882   {
66883     try {
66884       delete arg1;
66885     } catch (std::out_of_range& e) {
66886       {
66887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (std::exception& e) {
66890       {
66891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66892       };
66893     } catch (...) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66896       };
66897     }
66898   }
66899 }
66900
66901
66902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66903   int jresult ;
66904   int result;
66905
66906   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66907   jresult = (int)result;
66908   return jresult;
66909 }
66910
66911
66912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66913   int jresult ;
66914   int result;
66915
66916   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66917   jresult = (int)result;
66918   return jresult;
66919 }
66920
66921
66922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66923   int jresult ;
66924   int result;
66925
66926   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66927   jresult = (int)result;
66928   return jresult;
66929 }
66930
66931
66932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66933   void * jresult ;
66934   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66935
66936   {
66937     try {
66938       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66939     } catch (std::out_of_range& e) {
66940       {
66941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66942       };
66943     } catch (std::exception& e) {
66944       {
66945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66946       };
66947     } catch (...) {
66948       {
66949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66950       };
66951     }
66952   }
66953   jresult = (void *)result;
66954   return jresult;
66955 }
66956
66957
66958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66959   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66960
66961   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66962   {
66963     try {
66964       delete arg1;
66965     } catch (std::out_of_range& e) {
66966       {
66967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66968       };
66969     } catch (std::exception& e) {
66970       {
66971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66972       };
66973     } catch (...) {
66974       {
66975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66976       };
66977     }
66978   }
66979 }
66980
66981
66982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66983   void * jresult ;
66984   Dali::Toolkit::FlexContainer *result = 0 ;
66985
66986   {
66987     try {
66988       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66989     } catch (std::out_of_range& e) {
66990       {
66991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66992       };
66993     } catch (std::exception& e) {
66994       {
66995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66996       };
66997     } catch (...) {
66998       {
66999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67000       };
67001     }
67002   }
67003   jresult = (void *)result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
67009   void * jresult ;
67010   Dali::Toolkit::FlexContainer *arg1 = 0 ;
67011   Dali::Toolkit::FlexContainer *result = 0 ;
67012
67013   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67014   if (!arg1) {
67015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67016     return 0;
67017   }
67018   {
67019     try {
67020       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
67021     } catch (std::out_of_range& e) {
67022       {
67023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67024       };
67025     } catch (std::exception& e) {
67026       {
67027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67028       };
67029     } catch (...) {
67030       {
67031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67032       };
67033     }
67034   }
67035   jresult = (void *)result;
67036   return jresult;
67037 }
67038
67039
67040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
67041   void * jresult ;
67042   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67043   Dali::Toolkit::FlexContainer *arg2 = 0 ;
67044   Dali::Toolkit::FlexContainer *result = 0 ;
67045
67046   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67047   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
67048   if (!arg2) {
67049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67050     return 0;
67051   }
67052   {
67053     try {
67054       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67062       };
67063     } catch (...) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67066       };
67067     }
67068   }
67069   jresult = (void *)result;
67070   return jresult;
67071 }
67072
67073
67074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67075   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67076
67077   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67078   {
67079     try {
67080       delete arg1;
67081     } catch (std::out_of_range& e) {
67082       {
67083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67084       };
67085     } catch (std::exception& e) {
67086       {
67087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67088       };
67089     } catch (...) {
67090       {
67091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67092       };
67093     }
67094   }
67095 }
67096
67097
67098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67099   void * jresult ;
67100   Dali::Toolkit::FlexContainer result;
67101
67102   {
67103     try {
67104       result = Dali::Toolkit::FlexContainer::New();
67105     } catch (std::out_of_range& e) {
67106       {
67107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67108       };
67109     } catch (std::exception& e) {
67110       {
67111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67112       };
67113     } catch (...) {
67114       {
67115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67116       };
67117     }
67118   }
67119   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67120   return jresult;
67121 }
67122
67123
67124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67125   void * jresult ;
67126   Dali::BaseHandle arg1 ;
67127   Dali::BaseHandle *argp1 ;
67128   Dali::Toolkit::FlexContainer result;
67129
67130   argp1 = (Dali::BaseHandle *)jarg1;
67131   if (!argp1) {
67132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67133     return 0;
67134   }
67135   arg1 = *argp1;
67136   {
67137     try {
67138       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67139     } catch (std::out_of_range& e) {
67140       {
67141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67142       };
67143     } catch (std::exception& e) {
67144       {
67145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67146       };
67147     } catch (...) {
67148       {
67149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67150       };
67151     }
67152   }
67153   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67154   return jresult;
67155 }
67156
67157
67158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67159   int jresult ;
67160   int result;
67161
67162   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67163   jresult = (int)result;
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67169   int jresult ;
67170   int result;
67171
67172   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67173   jresult = (int)result;
67174   return jresult;
67175 }
67176
67177
67178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67179   int jresult ;
67180   int result;
67181
67182   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67183   jresult = (int)result;
67184   return jresult;
67185 }
67186
67187
67188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67189   int jresult ;
67190   int result;
67191
67192   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67193   jresult = (int)result;
67194   return jresult;
67195 }
67196
67197
67198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67199   void * jresult ;
67200   Dali::Toolkit::ImageView::Property *result = 0 ;
67201
67202   {
67203     try {
67204       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67205     } catch (std::out_of_range& e) {
67206       {
67207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67208       };
67209     } catch (std::exception& e) {
67210       {
67211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67212       };
67213     } catch (...) {
67214       {
67215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67216       };
67217     }
67218   }
67219   jresult = (void *)result;
67220   return jresult;
67221 }
67222
67223
67224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67225   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67226
67227   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67228   {
67229     try {
67230       delete arg1;
67231     } catch (std::out_of_range& e) {
67232       {
67233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67234       };
67235     } catch (std::exception& e) {
67236       {
67237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67238       };
67239     } catch (...) {
67240       {
67241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67242       };
67243     }
67244   }
67245 }
67246
67247
67248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67249   void * jresult ;
67250   Dali::Toolkit::ImageView *result = 0 ;
67251
67252   {
67253     try {
67254       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67255     } catch (std::out_of_range& e) {
67256       {
67257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67258       };
67259     } catch (std::exception& e) {
67260       {
67261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67262       };
67263     } catch (...) {
67264       {
67265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67266       };
67267     }
67268   }
67269   jresult = (void *)result;
67270   return jresult;
67271 }
67272
67273
67274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67275   void * jresult ;
67276   Dali::Toolkit::ImageView result;
67277
67278   {
67279     try {
67280       result = Dali::Toolkit::ImageView::New();
67281     } catch (std::out_of_range& e) {
67282       {
67283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67284       };
67285     } catch (std::exception& e) {
67286       {
67287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67288       };
67289     } catch (...) {
67290       {
67291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67292       };
67293     }
67294   }
67295   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67296   return jresult;
67297 }
67298
67299
67300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67301   void * jresult ;
67302   Dali::Image arg1 ;
67303   Dali::Image *argp1 ;
67304   Dali::Toolkit::ImageView result;
67305
67306   argp1 = (Dali::Image *)jarg1;
67307   if (!argp1) {
67308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67309     return 0;
67310   }
67311   arg1 = *argp1;
67312   {
67313     try {
67314       result = Dali::Toolkit::ImageView::New(arg1);
67315     } catch (std::out_of_range& e) {
67316       {
67317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67318       };
67319     } catch (std::exception& e) {
67320       {
67321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67322       };
67323     } catch (...) {
67324       {
67325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67326       };
67327     }
67328   }
67329   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67330   return jresult;
67331 }
67332
67333
67334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67335   void * jresult ;
67336   std::string *arg1 = 0 ;
67337   Dali::Toolkit::ImageView result;
67338
67339   if (!jarg1) {
67340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67341     return 0;
67342   }
67343   std::string arg1_str(jarg1);
67344   arg1 = &arg1_str;
67345   {
67346     try {
67347       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67348     } catch (std::out_of_range& e) {
67349       {
67350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67351       };
67352     } catch (std::exception& e) {
67353       {
67354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67355       };
67356     } catch (...) {
67357       {
67358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67359       };
67360     }
67361   }
67362   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67363
67364   //argout typemap for const std::string&
67365
67366   return jresult;
67367 }
67368
67369
67370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67371   void * jresult ;
67372   std::string *arg1 = 0 ;
67373   Dali::ImageDimensions arg2 ;
67374   Dali::ImageDimensions *argp2 ;
67375   Dali::Toolkit::ImageView result;
67376
67377   if (!jarg1) {
67378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67379     return 0;
67380   }
67381   std::string arg1_str(jarg1);
67382   arg1 = &arg1_str;
67383   argp2 = (Dali::ImageDimensions *)jarg2;
67384   if (!argp2) {
67385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67386     return 0;
67387   }
67388   arg2 = *argp2;
67389   {
67390     try {
67391       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67403       };
67404     }
67405   }
67406   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67407
67408   //argout typemap for const std::string&
67409
67410   return jresult;
67411 }
67412
67413
67414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67415   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67416
67417   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67418   {
67419     try {
67420       delete arg1;
67421     } catch (std::out_of_range& e) {
67422       {
67423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67424       };
67425     } catch (std::exception& e) {
67426       {
67427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67428       };
67429     } catch (...) {
67430       {
67431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67432       };
67433     }
67434   }
67435 }
67436
67437
67438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67439   void * jresult ;
67440   Dali::Toolkit::ImageView *arg1 = 0 ;
67441   Dali::Toolkit::ImageView *result = 0 ;
67442
67443   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67444   if (!arg1) {
67445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67446     return 0;
67447   }
67448   {
67449     try {
67450       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67451     } catch (std::out_of_range& e) {
67452       {
67453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67454       };
67455     } catch (std::exception& e) {
67456       {
67457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67458       };
67459     } catch (...) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67462       };
67463     }
67464   }
67465   jresult = (void *)result;
67466   return jresult;
67467 }
67468
67469
67470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67471   void * jresult ;
67472   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67473   Dali::Toolkit::ImageView *arg2 = 0 ;
67474   Dali::Toolkit::ImageView *result = 0 ;
67475
67476   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67477   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67478   if (!arg2) {
67479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67480     return 0;
67481   }
67482   {
67483     try {
67484       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67485     } catch (std::out_of_range& e) {
67486       {
67487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (std::exception& e) {
67490       {
67491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (...) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67496       };
67497     }
67498   }
67499   jresult = (void *)result;
67500   return jresult;
67501 }
67502
67503
67504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67505   void * jresult ;
67506   Dali::BaseHandle arg1 ;
67507   Dali::BaseHandle *argp1 ;
67508   Dali::Toolkit::ImageView result;
67509
67510   argp1 = (Dali::BaseHandle *)jarg1;
67511   if (!argp1) {
67512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67513     return 0;
67514   }
67515   arg1 = *argp1;
67516   {
67517     try {
67518       result = Dali::Toolkit::ImageView::DownCast(arg1);
67519     } catch (std::out_of_range& e) {
67520       {
67521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67522       };
67523     } catch (std::exception& e) {
67524       {
67525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (...) {
67528       {
67529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67530       };
67531     }
67532   }
67533   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67534   return jresult;
67535 }
67536
67537
67538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67539   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67540   Dali::Image arg2 ;
67541   Dali::Image *argp2 ;
67542
67543   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67544   argp2 = (Dali::Image *)jarg2;
67545   if (!argp2) {
67546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67547     return ;
67548   }
67549   arg2 = *argp2;
67550   {
67551     try {
67552       (arg1)->SetImage(arg2);
67553     } catch (std::out_of_range& e) {
67554       {
67555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67556       };
67557     } catch (std::exception& e) {
67558       {
67559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67560       };
67561     } catch (...) {
67562       {
67563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67564       };
67565     }
67566   }
67567 }
67568
67569
67570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67571   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67572   std::string *arg2 = 0 ;
67573
67574   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67575   if (!jarg2) {
67576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67577     return ;
67578   }
67579   std::string arg2_str(jarg2);
67580   arg2 = &arg2_str;
67581   {
67582     try {
67583       (arg1)->SetImage((std::string const &)*arg2);
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67591       };
67592     } catch (...) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67595       };
67596     }
67597   }
67598
67599   //argout typemap for const std::string&
67600
67601 }
67602
67603
67604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67605   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67606   std::string *arg2 = 0 ;
67607   Dali::ImageDimensions arg3 ;
67608   Dali::ImageDimensions *argp3 ;
67609
67610   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67611   if (!jarg2) {
67612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67613     return ;
67614   }
67615   std::string arg2_str(jarg2);
67616   arg2 = &arg2_str;
67617   argp3 = (Dali::ImageDimensions *)jarg3;
67618   if (!argp3) {
67619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67620     return ;
67621   }
67622   arg3 = *argp3;
67623   {
67624     try {
67625       (arg1)->SetImage((std::string const &)*arg2,arg3);
67626     } catch (std::out_of_range& e) {
67627       {
67628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67629       };
67630     } catch (std::exception& e) {
67631       {
67632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67633       };
67634     } catch (...) {
67635       {
67636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67637       };
67638     }
67639   }
67640
67641   //argout typemap for const std::string&
67642
67643 }
67644
67645
67646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67647   void * jresult ;
67648   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67649   Dali::Image result;
67650
67651   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67652   {
67653     try {
67654       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67655     } catch (std::out_of_range& e) {
67656       {
67657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67658       };
67659     } catch (std::exception& e) {
67660       {
67661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (...) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67666       };
67667     }
67668   }
67669   jresult = new Dali::Image((const Dali::Image &)result);
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67675   int jresult ;
67676   int result;
67677
67678   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67679   jresult = (int)result;
67680   return jresult;
67681 }
67682
67683
67684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67685   int jresult ;
67686   int result;
67687
67688   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67689   jresult = (int)result;
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67695   int jresult ;
67696   int result;
67697
67698   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67699   jresult = (int)result;
67700   return jresult;
67701 }
67702
67703
67704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67705   int jresult ;
67706   int result;
67707
67708   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67709   jresult = (int)result;
67710   return jresult;
67711 }
67712
67713
67714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67715   int jresult ;
67716   int result;
67717
67718   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67719   jresult = (int)result;
67720   return jresult;
67721 }
67722
67723
67724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67725   int jresult ;
67726   int result;
67727
67728   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67729   jresult = (int)result;
67730   return jresult;
67731 }
67732
67733
67734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67735   int jresult ;
67736   int result;
67737
67738   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67739   jresult = (int)result;
67740   return jresult;
67741 }
67742
67743
67744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67745   int jresult ;
67746   int result;
67747
67748   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67749   jresult = (int)result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67755   void * jresult ;
67756   Dali::Toolkit::Model3dView::Property *result = 0 ;
67757
67758   {
67759     try {
67760       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67761     } catch (std::out_of_range& e) {
67762       {
67763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67764       };
67765     } catch (std::exception& e) {
67766       {
67767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67768       };
67769     } catch (...) {
67770       {
67771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67772       };
67773     }
67774   }
67775   jresult = (void *)result;
67776   return jresult;
67777 }
67778
67779
67780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67781   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67782
67783   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67784   {
67785     try {
67786       delete arg1;
67787     } catch (std::out_of_range& e) {
67788       {
67789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67790       };
67791     } catch (std::exception& e) {
67792       {
67793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67794       };
67795     } catch (...) {
67796       {
67797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67798       };
67799     }
67800   }
67801 }
67802
67803
67804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67805   void * jresult ;
67806   Dali::Toolkit::Model3dView result;
67807
67808   {
67809     try {
67810       result = Dali::Toolkit::Model3dView::New();
67811     } catch (std::out_of_range& e) {
67812       {
67813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67814       };
67815     } catch (std::exception& e) {
67816       {
67817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67818       };
67819     } catch (...) {
67820       {
67821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67822       };
67823     }
67824   }
67825   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67826   return jresult;
67827 }
67828
67829
67830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67831   void * jresult ;
67832   std::string *arg1 = 0 ;
67833   std::string *arg2 = 0 ;
67834   std::string *arg3 = 0 ;
67835   Dali::Toolkit::Model3dView result;
67836
67837   if (!jarg1) {
67838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67839     return 0;
67840   }
67841   std::string arg1_str(jarg1);
67842   arg1 = &arg1_str;
67843   if (!jarg2) {
67844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67845     return 0;
67846   }
67847   std::string arg2_str(jarg2);
67848   arg2 = &arg2_str;
67849   if (!jarg3) {
67850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67851     return 0;
67852   }
67853   std::string arg3_str(jarg3);
67854   arg3 = &arg3_str;
67855   {
67856     try {
67857       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67858     } catch (std::out_of_range& e) {
67859       {
67860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67861       };
67862     } catch (std::exception& e) {
67863       {
67864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67869       };
67870     }
67871   }
67872   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67873
67874   //argout typemap for const std::string&
67875
67876
67877   //argout typemap for const std::string&
67878
67879
67880   //argout typemap for const std::string&
67881
67882   return jresult;
67883 }
67884
67885
67886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67887   void * jresult ;
67888   Dali::Toolkit::Model3dView *result = 0 ;
67889
67890   {
67891     try {
67892       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67893     } catch (std::out_of_range& e) {
67894       {
67895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (std::exception& e) {
67898       {
67899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67904       };
67905     }
67906   }
67907   jresult = (void *)result;
67908   return jresult;
67909 }
67910
67911
67912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67913   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67914
67915   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67916   {
67917     try {
67918       delete arg1;
67919     } catch (std::out_of_range& e) {
67920       {
67921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67922       };
67923     } catch (std::exception& e) {
67924       {
67925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67926       };
67927     } catch (...) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67930       };
67931     }
67932   }
67933 }
67934
67935
67936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67937   void * jresult ;
67938   Dali::Toolkit::Model3dView *arg1 = 0 ;
67939   Dali::Toolkit::Model3dView *result = 0 ;
67940
67941   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67942   if (!arg1) {
67943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67944     return 0;
67945   }
67946   {
67947     try {
67948       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67949     } catch (std::out_of_range& e) {
67950       {
67951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67952       };
67953     } catch (std::exception& e) {
67954       {
67955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67956       };
67957     } catch (...) {
67958       {
67959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67960       };
67961     }
67962   }
67963   jresult = (void *)result;
67964   return jresult;
67965 }
67966
67967
67968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67969   void * jresult ;
67970   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67971   Dali::Toolkit::Model3dView *arg2 = 0 ;
67972   Dali::Toolkit::Model3dView *result = 0 ;
67973
67974   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67975   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67976   if (!arg2) {
67977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67978     return 0;
67979   }
67980   {
67981     try {
67982       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67983     } catch (std::out_of_range& e) {
67984       {
67985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67986       };
67987     } catch (std::exception& e) {
67988       {
67989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67990       };
67991     } catch (...) {
67992       {
67993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67994       };
67995     }
67996   }
67997   jresult = (void *)result;
67998   return jresult;
67999 }
68000
68001
68002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
68003   void * jresult ;
68004   Dali::BaseHandle arg1 ;
68005   Dali::BaseHandle *argp1 ;
68006   Dali::Toolkit::Model3dView result;
68007
68008   argp1 = (Dali::BaseHandle *)jarg1;
68009   if (!argp1) {
68010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68011     return 0;
68012   }
68013   arg1 = *argp1;
68014   {
68015     try {
68016       result = Dali::Toolkit::Model3dView::DownCast(arg1);
68017     } catch (std::out_of_range& e) {
68018       {
68019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68020       };
68021     } catch (std::exception& e) {
68022       {
68023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68024       };
68025     } catch (...) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68028       };
68029     }
68030   }
68031   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68032   return jresult;
68033 }
68034
68035
68036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
68037   int jresult ;
68038   int result;
68039
68040   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
68041   jresult = (int)result;
68042   return jresult;
68043 }
68044
68045
68046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
68047   int jresult ;
68048   int result;
68049
68050   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
68051   jresult = (int)result;
68052   return jresult;
68053 }
68054
68055
68056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
68057   int jresult ;
68058   int result;
68059
68060   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68061   jresult = (int)result;
68062   return jresult;
68063 }
68064
68065
68066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68067   int jresult ;
68068   int result;
68069
68070   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68071   jresult = (int)result;
68072   return jresult;
68073 }
68074
68075
68076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68077   int jresult ;
68078   int result;
68079
68080   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68081   jresult = (int)result;
68082   return jresult;
68083 }
68084
68085
68086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68087   int jresult ;
68088   int result;
68089
68090   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68091   jresult = (int)result;
68092   return jresult;
68093 }
68094
68095
68096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68097   int jresult ;
68098   int result;
68099
68100   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68101   jresult = (int)result;
68102   return jresult;
68103 }
68104
68105
68106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68107   int jresult ;
68108   int result;
68109
68110   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68111   jresult = (int)result;
68112   return jresult;
68113 }
68114
68115
68116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68117   int jresult ;
68118   int result;
68119
68120   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68121   jresult = (int)result;
68122   return jresult;
68123 }
68124
68125
68126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68127   void * jresult ;
68128   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68129
68130   {
68131     try {
68132       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68133     } catch (std::out_of_range& e) {
68134       {
68135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68136       };
68137     } catch (std::exception& e) {
68138       {
68139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68140       };
68141     } catch (...) {
68142       {
68143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68144       };
68145     }
68146   }
68147   jresult = (void *)result;
68148   return jresult;
68149 }
68150
68151
68152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68153   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68154
68155   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68156   {
68157     try {
68158       delete arg1;
68159     } catch (std::out_of_range& e) {
68160       {
68161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68162       };
68163     } catch (std::exception& e) {
68164       {
68165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68166       };
68167     } catch (...) {
68168       {
68169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68170       };
68171     }
68172   }
68173 }
68174
68175
68176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68177   void * jresult ;
68178   Dali::Toolkit::ScrollBar *result = 0 ;
68179
68180   {
68181     try {
68182       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68183     } catch (std::out_of_range& e) {
68184       {
68185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68186       };
68187     } catch (std::exception& e) {
68188       {
68189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68190       };
68191     } catch (...) {
68192       {
68193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68194       };
68195     }
68196   }
68197   jresult = (void *)result;
68198   return jresult;
68199 }
68200
68201
68202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68203   void * jresult ;
68204   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68205   Dali::Toolkit::ScrollBar *result = 0 ;
68206
68207   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68208   if (!arg1) {
68209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68210     return 0;
68211   }
68212   {
68213     try {
68214       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68215     } catch (std::out_of_range& e) {
68216       {
68217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68218       };
68219     } catch (std::exception& e) {
68220       {
68221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68222       };
68223     } catch (...) {
68224       {
68225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68226       };
68227     }
68228   }
68229   jresult = (void *)result;
68230   return jresult;
68231 }
68232
68233
68234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68235   void * jresult ;
68236   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68237   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68238   Dali::Toolkit::ScrollBar *result = 0 ;
68239
68240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68241   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68242   if (!arg2) {
68243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68244     return 0;
68245   }
68246   {
68247     try {
68248       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68249     } catch (std::out_of_range& e) {
68250       {
68251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68252       };
68253     } catch (std::exception& e) {
68254       {
68255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68256       };
68257     } catch (...) {
68258       {
68259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68260       };
68261     }
68262   }
68263   jresult = (void *)result;
68264   return jresult;
68265 }
68266
68267
68268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68269   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68270
68271   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68272   {
68273     try {
68274       delete arg1;
68275     } catch (std::out_of_range& e) {
68276       {
68277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68278       };
68279     } catch (std::exception& e) {
68280       {
68281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68282       };
68283     } catch (...) {
68284       {
68285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68286       };
68287     }
68288   }
68289 }
68290
68291
68292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68293   void * jresult ;
68294   Dali::Toolkit::ScrollBar::Direction arg1 ;
68295   Dali::Toolkit::ScrollBar result;
68296
68297   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68298   {
68299     try {
68300       result = Dali::Toolkit::ScrollBar::New(arg1);
68301     } catch (std::out_of_range& e) {
68302       {
68303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68304       };
68305     } catch (std::exception& e) {
68306       {
68307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68308       };
68309     } catch (...) {
68310       {
68311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68312       };
68313     }
68314   }
68315   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68316   return jresult;
68317 }
68318
68319
68320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68321   void * jresult ;
68322   Dali::Toolkit::ScrollBar result;
68323
68324   {
68325     try {
68326       result = Dali::Toolkit::ScrollBar::New();
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (...) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68338       };
68339     }
68340   }
68341   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68342   return jresult;
68343 }
68344
68345
68346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68347   void * jresult ;
68348   Dali::BaseHandle arg1 ;
68349   Dali::BaseHandle *argp1 ;
68350   Dali::Toolkit::ScrollBar result;
68351
68352   argp1 = (Dali::BaseHandle *)jarg1;
68353   if (!argp1) {
68354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68355     return 0;
68356   }
68357   arg1 = *argp1;
68358   {
68359     try {
68360       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68361     } catch (std::out_of_range& e) {
68362       {
68363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68364       };
68365     } catch (std::exception& e) {
68366       {
68367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68368       };
68369     } catch (...) {
68370       {
68371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68372       };
68373     }
68374   }
68375   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68376   return jresult;
68377 }
68378
68379
68380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68381   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68382   Dali::Handle arg2 ;
68383   Dali::Property::Index arg3 ;
68384   Dali::Property::Index arg4 ;
68385   Dali::Property::Index arg5 ;
68386   Dali::Property::Index arg6 ;
68387   Dali::Handle *argp2 ;
68388
68389   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68390   argp2 = (Dali::Handle *)jarg2;
68391   if (!argp2) {
68392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68393     return ;
68394   }
68395   arg2 = *argp2;
68396   arg3 = (Dali::Property::Index)jarg3;
68397   arg4 = (Dali::Property::Index)jarg4;
68398   arg5 = (Dali::Property::Index)jarg5;
68399   arg6 = (Dali::Property::Index)jarg6;
68400   {
68401     try {
68402       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68403     } catch (std::out_of_range& e) {
68404       {
68405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68406       };
68407     } catch (std::exception& e) {
68408       {
68409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68410       };
68411     } catch (...) {
68412       {
68413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68414       };
68415     }
68416   }
68417 }
68418
68419
68420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68421   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68422   Dali::Actor arg2 ;
68423   Dali::Actor *argp2 ;
68424
68425   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68426   argp2 = (Dali::Actor *)jarg2;
68427   if (!argp2) {
68428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68429     return ;
68430   }
68431   arg2 = *argp2;
68432   {
68433     try {
68434       (arg1)->SetScrollIndicator(arg2);
68435     } catch (std::out_of_range& e) {
68436       {
68437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68438       };
68439     } catch (std::exception& e) {
68440       {
68441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68442       };
68443     } catch (...) {
68444       {
68445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68446       };
68447     }
68448   }
68449 }
68450
68451
68452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68453   void * jresult ;
68454   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68455   Dali::Actor result;
68456
68457   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68458   {
68459     try {
68460       result = (arg1)->GetScrollIndicator();
68461     } catch (std::out_of_range& e) {
68462       {
68463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68464       };
68465     } catch (std::exception& e) {
68466       {
68467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68468       };
68469     } catch (...) {
68470       {
68471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68472       };
68473     }
68474   }
68475   jresult = new Dali::Actor((const Dali::Actor &)result);
68476   return jresult;
68477 }
68478
68479
68480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68481   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68482   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68483
68484   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68485   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68486   if (!arg2) {
68487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68488     return ;
68489   }
68490   {
68491     try {
68492       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68493     } catch (std::out_of_range& e) {
68494       {
68495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68496       };
68497     } catch (std::exception& e) {
68498       {
68499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68500       };
68501     } catch (...) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68504       };
68505     }
68506   }
68507 }
68508
68509
68510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68511   void * jresult ;
68512   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68513   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68514
68515   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68516   {
68517     try {
68518       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68519     } catch (std::out_of_range& e) {
68520       {
68521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68522       };
68523     } catch (std::exception& e) {
68524       {
68525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (...) {
68528       {
68529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68530       };
68531     }
68532   }
68533   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68534   return jresult;
68535 }
68536
68537
68538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68539   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68540   Dali::Toolkit::ScrollBar::Direction arg2 ;
68541
68542   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68543   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68544   {
68545     try {
68546       (arg1)->SetScrollDirection(arg2);
68547     } catch (std::out_of_range& e) {
68548       {
68549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68550       };
68551     } catch (std::exception& e) {
68552       {
68553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68554       };
68555     } catch (...) {
68556       {
68557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68558       };
68559     }
68560   }
68561 }
68562
68563
68564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68565   int jresult ;
68566   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68567   Dali::Toolkit::ScrollBar::Direction result;
68568
68569   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68570   {
68571     try {
68572       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68573     } catch (std::out_of_range& e) {
68574       {
68575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68576       };
68577     } catch (std::exception& e) {
68578       {
68579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68580       };
68581     } catch (...) {
68582       {
68583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68584       };
68585     }
68586   }
68587   jresult = (int)result;
68588   return jresult;
68589 }
68590
68591
68592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68593   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68594   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68595
68596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68597   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68598   {
68599     try {
68600       (arg1)->SetIndicatorHeightPolicy(arg2);
68601     } catch (std::out_of_range& e) {
68602       {
68603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68604       };
68605     } catch (std::exception& e) {
68606       {
68607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68608       };
68609     } catch (...) {
68610       {
68611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68612       };
68613     }
68614   }
68615 }
68616
68617
68618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68619   int jresult ;
68620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68621   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68622
68623   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68624   {
68625     try {
68626       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68627     } catch (std::out_of_range& e) {
68628       {
68629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68630       };
68631     } catch (std::exception& e) {
68632       {
68633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68634       };
68635     } catch (...) {
68636       {
68637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68638       };
68639     }
68640   }
68641   jresult = (int)result;
68642   return jresult;
68643 }
68644
68645
68646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68647   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68648   float arg2 ;
68649
68650   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68651   arg2 = (float)jarg2;
68652   {
68653     try {
68654       (arg1)->SetIndicatorFixedHeight(arg2);
68655     } catch (std::out_of_range& e) {
68656       {
68657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68658       };
68659     } catch (std::exception& e) {
68660       {
68661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68662       };
68663     } catch (...) {
68664       {
68665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68666       };
68667     }
68668   }
68669 }
68670
68671
68672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68673   float jresult ;
68674   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68675   float result;
68676
68677   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68678   {
68679     try {
68680       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68681     } catch (std::out_of_range& e) {
68682       {
68683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68684       };
68685     } catch (std::exception& e) {
68686       {
68687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68688       };
68689     } catch (...) {
68690       {
68691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68692       };
68693     }
68694   }
68695   jresult = result;
68696   return jresult;
68697 }
68698
68699
68700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68701   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68702   float arg2 ;
68703
68704   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68705   arg2 = (float)jarg2;
68706   {
68707     try {
68708       (arg1)->SetIndicatorShowDuration(arg2);
68709     } catch (std::out_of_range& e) {
68710       {
68711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68712       };
68713     } catch (std::exception& e) {
68714       {
68715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68716       };
68717     } catch (...) {
68718       {
68719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68720       };
68721     }
68722   }
68723 }
68724
68725
68726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68727   float jresult ;
68728   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68729   float result;
68730
68731   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68732   {
68733     try {
68734       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68735     } catch (std::out_of_range& e) {
68736       {
68737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68738       };
68739     } catch (std::exception& e) {
68740       {
68741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68746       };
68747     }
68748   }
68749   jresult = result;
68750   return jresult;
68751 }
68752
68753
68754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68755   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68756   float arg2 ;
68757
68758   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68759   arg2 = (float)jarg2;
68760   {
68761     try {
68762       (arg1)->SetIndicatorHideDuration(arg2);
68763     } catch (std::out_of_range& e) {
68764       {
68765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68766       };
68767     } catch (std::exception& e) {
68768       {
68769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68770       };
68771     } catch (...) {
68772       {
68773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68774       };
68775     }
68776   }
68777 }
68778
68779
68780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68781   float jresult ;
68782   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68783   float result;
68784
68785   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68786   {
68787     try {
68788       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68789     } catch (std::out_of_range& e) {
68790       {
68791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68792       };
68793     } catch (std::exception& e) {
68794       {
68795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68796       };
68797     } catch (...) {
68798       {
68799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68800       };
68801     }
68802   }
68803   jresult = result;
68804   return jresult;
68805 }
68806
68807
68808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68809   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68810
68811   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68812   {
68813     try {
68814       (arg1)->ShowIndicator();
68815     } catch (std::out_of_range& e) {
68816       {
68817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68818       };
68819     } catch (std::exception& e) {
68820       {
68821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68822       };
68823     } catch (...) {
68824       {
68825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68826       };
68827     }
68828   }
68829 }
68830
68831
68832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68833   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68834
68835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68836   {
68837     try {
68838       (arg1)->HideIndicator();
68839     } catch (std::out_of_range& e) {
68840       {
68841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68842       };
68843     } catch (std::exception& e) {
68844       {
68845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68846       };
68847     } catch (...) {
68848       {
68849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68850       };
68851     }
68852   }
68853 }
68854
68855
68856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68857   void * jresult ;
68858   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68859   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68860
68861   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68862   {
68863     try {
68864       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68865     } catch (std::out_of_range& e) {
68866       {
68867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68868       };
68869     } catch (std::exception& e) {
68870       {
68871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68872       };
68873     } catch (...) {
68874       {
68875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68876       };
68877     }
68878   }
68879   jresult = (void *)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68885   void * jresult ;
68886   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68887   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68888
68889   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68890   {
68891     try {
68892       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68893     } catch (std::out_of_range& e) {
68894       {
68895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68896       };
68897     } catch (std::exception& e) {
68898       {
68899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68900       };
68901     } catch (...) {
68902       {
68903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68904       };
68905     }
68906   }
68907   jresult = (void *)result;
68908   return jresult;
68909 }
68910
68911
68912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68913   int jresult ;
68914   int result;
68915
68916   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68917   jresult = (int)result;
68918   return jresult;
68919 }
68920
68921
68922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68923   int jresult ;
68924   int result;
68925
68926   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68927   jresult = (int)result;
68928   return jresult;
68929 }
68930
68931
68932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68933   int jresult ;
68934   int result;
68935
68936   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68937   jresult = (int)result;
68938   return jresult;
68939 }
68940
68941
68942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68943   int jresult ;
68944   int result;
68945
68946   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68947   jresult = (int)result;
68948   return jresult;
68949 }
68950
68951
68952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68953   int jresult ;
68954   int result;
68955
68956   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68957   jresult = (int)result;
68958   return jresult;
68959 }
68960
68961
68962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68963   int jresult ;
68964   int result;
68965
68966   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68967   jresult = (int)result;
68968   return jresult;
68969 }
68970
68971
68972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68973   int jresult ;
68974   int result;
68975
68976   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68977   jresult = (int)result;
68978   return jresult;
68979 }
68980
68981
68982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68983   int jresult ;
68984   int result;
68985
68986   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68987   jresult = (int)result;
68988   return jresult;
68989 }
68990
68991
68992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68993   int jresult ;
68994   int result;
68995
68996   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68997   jresult = (int)result;
68998   return jresult;
68999 }
69000
69001
69002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
69003   int jresult ;
69004   int result;
69005
69006   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
69007   jresult = (int)result;
69008   return jresult;
69009 }
69010
69011
69012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
69013   int jresult ;
69014   int result;
69015
69016   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
69017   jresult = (int)result;
69018   return jresult;
69019 }
69020
69021
69022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
69023   int jresult ;
69024   int result;
69025
69026   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
69027   jresult = (int)result;
69028   return jresult;
69029 }
69030
69031
69032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
69033   int jresult ;
69034   int result;
69035
69036   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69037   jresult = (int)result;
69038   return jresult;
69039 }
69040
69041
69042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69043   int jresult ;
69044   int result;
69045
69046   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69047   jresult = (int)result;
69048   return jresult;
69049 }
69050
69051
69052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69053   void * jresult ;
69054   Dali::Toolkit::Scrollable::Property *result = 0 ;
69055
69056   {
69057     try {
69058       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69059     } catch (std::out_of_range& e) {
69060       {
69061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69062       };
69063     } catch (std::exception& e) {
69064       {
69065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69066       };
69067     } catch (...) {
69068       {
69069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69070       };
69071     }
69072   }
69073   jresult = (void *)result;
69074   return jresult;
69075 }
69076
69077
69078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
69079   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69080
69081   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
69082   {
69083     try {
69084       delete arg1;
69085     } catch (std::out_of_range& e) {
69086       {
69087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69088       };
69089     } catch (std::exception& e) {
69090       {
69091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69092       };
69093     } catch (...) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69096       };
69097     }
69098   }
69099 }
69100
69101
69102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
69103   void * jresult ;
69104   Dali::Toolkit::Scrollable *result = 0 ;
69105
69106   {
69107     try {
69108       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69109     } catch (std::out_of_range& e) {
69110       {
69111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69112       };
69113     } catch (std::exception& e) {
69114       {
69115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69116       };
69117     } catch (...) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69120       };
69121     }
69122   }
69123   jresult = (void *)result;
69124   return jresult;
69125 }
69126
69127
69128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69129   void * jresult ;
69130   Dali::Toolkit::Scrollable *arg1 = 0 ;
69131   Dali::Toolkit::Scrollable *result = 0 ;
69132
69133   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69134   if (!arg1) {
69135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69136     return 0;
69137   }
69138   {
69139     try {
69140       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69141     } catch (std::out_of_range& e) {
69142       {
69143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (std::exception& e) {
69146       {
69147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69152       };
69153     }
69154   }
69155   jresult = (void *)result;
69156   return jresult;
69157 }
69158
69159
69160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69161   void * jresult ;
69162   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69163   Dali::Toolkit::Scrollable *arg2 = 0 ;
69164   Dali::Toolkit::Scrollable *result = 0 ;
69165
69166   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69167   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69168   if (!arg2) {
69169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69170     return 0;
69171   }
69172   {
69173     try {
69174       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69175     } catch (std::out_of_range& e) {
69176       {
69177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (std::exception& e) {
69180       {
69181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69182       };
69183     } catch (...) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69186       };
69187     }
69188   }
69189   jresult = (void *)result;
69190   return jresult;
69191 }
69192
69193
69194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69195   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69196
69197   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69198   {
69199     try {
69200       delete arg1;
69201     } catch (std::out_of_range& e) {
69202       {
69203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69204       };
69205     } catch (std::exception& e) {
69206       {
69207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69208       };
69209     } catch (...) {
69210       {
69211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69212       };
69213     }
69214   }
69215 }
69216
69217
69218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69219   void * jresult ;
69220   Dali::BaseHandle arg1 ;
69221   Dali::BaseHandle *argp1 ;
69222   Dali::Toolkit::Scrollable result;
69223
69224   argp1 = (Dali::BaseHandle *)jarg1;
69225   if (!argp1) {
69226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69227     return 0;
69228   }
69229   arg1 = *argp1;
69230   {
69231     try {
69232       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69233     } catch (std::out_of_range& e) {
69234       {
69235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69236       };
69237     } catch (std::exception& e) {
69238       {
69239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69240       };
69241     } catch (...) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69244       };
69245     }
69246   }
69247   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69248   return jresult;
69249 }
69250
69251
69252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69253   unsigned int jresult ;
69254   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69255   bool result;
69256
69257   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69258   {
69259     try {
69260       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69261     } catch (std::out_of_range& e) {
69262       {
69263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69264       };
69265     } catch (std::exception& e) {
69266       {
69267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69268       };
69269     } catch (...) {
69270       {
69271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69272       };
69273     }
69274   }
69275   jresult = result;
69276   return jresult;
69277 }
69278
69279
69280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69281   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69282   bool arg2 ;
69283
69284   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69285   arg2 = jarg2 ? true : false;
69286   {
69287     try {
69288       (arg1)->SetOvershootEnabled(arg2);
69289     } catch (std::out_of_range& e) {
69290       {
69291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69292       };
69293     } catch (std::exception& e) {
69294       {
69295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69296       };
69297     } catch (...) {
69298       {
69299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69300       };
69301     }
69302   }
69303 }
69304
69305
69306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69307   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69308   Dali::Vector4 *arg2 = 0 ;
69309
69310   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69311   arg2 = (Dali::Vector4 *)jarg2;
69312   if (!arg2) {
69313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69314     return ;
69315   }
69316   {
69317     try {
69318       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69319     } catch (std::out_of_range& e) {
69320       {
69321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69322       };
69323     } catch (std::exception& e) {
69324       {
69325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69330       };
69331     }
69332   }
69333 }
69334
69335
69336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69337   void * jresult ;
69338   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69339   Dali::Vector4 result;
69340
69341   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69342   {
69343     try {
69344       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69345     } catch (std::out_of_range& e) {
69346       {
69347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69348       };
69349     } catch (std::exception& e) {
69350       {
69351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69352       };
69353     } catch (...) {
69354       {
69355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69356       };
69357     }
69358   }
69359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69360   return jresult;
69361 }
69362
69363
69364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69365   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69366   float arg2 ;
69367
69368   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69369   arg2 = (float)jarg2;
69370   {
69371     try {
69372       (arg1)->SetOvershootAnimationSpeed(arg2);
69373     } catch (std::out_of_range& e) {
69374       {
69375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69376       };
69377     } catch (std::exception& e) {
69378       {
69379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69380       };
69381     } catch (...) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69384       };
69385     }
69386   }
69387 }
69388
69389
69390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69391   float jresult ;
69392   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69393   float result;
69394
69395   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69396   {
69397     try {
69398       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69406       };
69407     } catch (...) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69410       };
69411     }
69412   }
69413   jresult = result;
69414   return jresult;
69415 }
69416
69417
69418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69419   void * jresult ;
69420   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69421   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69422
69423   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69424   {
69425     try {
69426       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69427     } catch (std::out_of_range& e) {
69428       {
69429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69430       };
69431     } catch (std::exception& e) {
69432       {
69433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69434       };
69435     } catch (...) {
69436       {
69437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69438       };
69439     }
69440   }
69441   jresult = (void *)result;
69442   return jresult;
69443 }
69444
69445
69446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69447   void * jresult ;
69448   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69449   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69450
69451   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69452   {
69453     try {
69454       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69455     } catch (std::out_of_range& e) {
69456       {
69457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69458       };
69459     } catch (std::exception& e) {
69460       {
69461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69462       };
69463     } catch (...) {
69464       {
69465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69466       };
69467     }
69468   }
69469   jresult = (void *)result;
69470   return jresult;
69471 }
69472
69473
69474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69475   void * jresult ;
69476   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69477   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69478
69479   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69480   {
69481     try {
69482       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69483     } catch (std::out_of_range& e) {
69484       {
69485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69486       };
69487     } catch (std::exception& e) {
69488       {
69489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69490       };
69491     } catch (...) {
69492       {
69493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69494       };
69495     }
69496   }
69497   jresult = (void *)result;
69498   return jresult;
69499 }
69500
69501
69502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69503   unsigned int jresult ;
69504   Dali::Toolkit::ControlOrientation::Type arg1 ;
69505   bool result;
69506
69507   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69508   {
69509     try {
69510       result = (bool)Dali::Toolkit::IsVertical(arg1);
69511     } catch (std::out_of_range& e) {
69512       {
69513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69514       };
69515     } catch (std::exception& e) {
69516       {
69517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69518       };
69519     } catch (...) {
69520       {
69521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69522       };
69523     }
69524   }
69525   jresult = result;
69526   return jresult;
69527 }
69528
69529
69530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69531   unsigned int jresult ;
69532   Dali::Toolkit::ControlOrientation::Type arg1 ;
69533   bool result;
69534
69535   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69536   {
69537     try {
69538       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69539     } catch (std::out_of_range& e) {
69540       {
69541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69542       };
69543     } catch (std::exception& e) {
69544       {
69545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69546       };
69547     } catch (...) {
69548       {
69549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69550       };
69551     }
69552   }
69553   jresult = result;
69554   return jresult;
69555 }
69556
69557
69558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69559   void * jresult ;
69560   unsigned int arg1 ;
69561   unsigned int arg2 ;
69562   Dali::Toolkit::ItemRange *result = 0 ;
69563
69564   arg1 = (unsigned int)jarg1;
69565   arg2 = (unsigned int)jarg2;
69566   {
69567     try {
69568       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69569     } catch (std::out_of_range& e) {
69570       {
69571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (std::exception& e) {
69574       {
69575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (...) {
69578       {
69579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69580       };
69581     }
69582   }
69583   jresult = (void *)result;
69584   return jresult;
69585 }
69586
69587
69588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69589   void * jresult ;
69590   Dali::Toolkit::ItemRange *arg1 = 0 ;
69591   Dali::Toolkit::ItemRange *result = 0 ;
69592
69593   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69594   if (!arg1) {
69595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69596     return 0;
69597   }
69598   {
69599     try {
69600       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (...) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69612       };
69613     }
69614   }
69615   jresult = (void *)result;
69616   return jresult;
69617 }
69618
69619
69620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69621   void * jresult ;
69622   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69623   Dali::Toolkit::ItemRange *arg2 = 0 ;
69624   Dali::Toolkit::ItemRange *result = 0 ;
69625
69626   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69627   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69628   if (!arg2) {
69629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69630     return 0;
69631   }
69632   {
69633     try {
69634       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69635     } catch (std::out_of_range& e) {
69636       {
69637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69638       };
69639     } catch (std::exception& e) {
69640       {
69641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69642       };
69643     } catch (...) {
69644       {
69645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69646       };
69647     }
69648   }
69649   jresult = (void *)result;
69650   return jresult;
69651 }
69652
69653
69654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69655   unsigned int jresult ;
69656   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69657   unsigned int arg2 ;
69658   bool result;
69659
69660   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69661   arg2 = (unsigned int)jarg2;
69662   {
69663     try {
69664       result = (bool)(arg1)->Within(arg2);
69665     } catch (std::out_of_range& e) {
69666       {
69667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69668       };
69669     } catch (std::exception& e) {
69670       {
69671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69672       };
69673     } catch (...) {
69674       {
69675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69676       };
69677     }
69678   }
69679   jresult = result;
69680   return jresult;
69681 }
69682
69683
69684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69685   void * jresult ;
69686   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69687   Dali::Toolkit::ItemRange *arg2 = 0 ;
69688   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69689
69690   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69691   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69692   if (!arg2) {
69693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69694     return 0;
69695   }
69696   {
69697     try {
69698       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69699     } catch (std::out_of_range& e) {
69700       {
69701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69702       };
69703     } catch (std::exception& e) {
69704       {
69705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69706       };
69707     } catch (...) {
69708       {
69709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69710       };
69711     }
69712   }
69713   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69714   return jresult;
69715 }
69716
69717
69718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin = arg2;
69725 }
69726
69727
69728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin);
69735   jresult = result;
69736   return jresult;
69737 }
69738
69739
69740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69741   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69742   unsigned int arg2 ;
69743
69744   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69745   arg2 = (unsigned int)jarg2;
69746   if (arg1) (arg1)->end = arg2;
69747 }
69748
69749
69750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69751   unsigned int jresult ;
69752   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69753   unsigned int result;
69754
69755   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69756   result = (unsigned int) ((arg1)->end);
69757   jresult = result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69763   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69764
69765   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69766   {
69767     try {
69768       delete arg1;
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69776       };
69777     } catch (...) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69780       };
69781     }
69782   }
69783 }
69784
69785
69786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69787   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69788
69789   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69790   {
69791     try {
69792       delete arg1;
69793     } catch (std::out_of_range& e) {
69794       {
69795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69796       };
69797     } catch (std::exception& e) {
69798       {
69799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69800       };
69801     } catch (...) {
69802       {
69803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69804       };
69805     }
69806   }
69807 }
69808
69809
69810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69811   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69812   Dali::Toolkit::ControlOrientation::Type arg2 ;
69813
69814   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69815   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69816   {
69817     try {
69818       (arg1)->SetOrientation(arg2);
69819     } catch (std::out_of_range& e) {
69820       {
69821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69822       };
69823     } catch (std::exception& e) {
69824       {
69825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69826       };
69827     } catch (...) {
69828       {
69829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69830       };
69831     }
69832   }
69833 }
69834
69835
69836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69837   int jresult ;
69838   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69839   Dali::Toolkit::ControlOrientation::Type result;
69840
69841   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69842   {
69843     try {
69844       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69856       };
69857     }
69858   }
69859   jresult = (int)result;
69860   return jresult;
69861 }
69862
69863
69864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69865   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69866   Dali::Property::Map *arg2 = 0 ;
69867
69868   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69869   arg2 = (Dali::Property::Map *)jarg2;
69870   if (!arg2) {
69871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69872     return ;
69873   }
69874   {
69875     try {
69876       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69877     } catch (std::out_of_range& e) {
69878       {
69879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69880       };
69881     } catch (std::exception& e) {
69882       {
69883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69884       };
69885     } catch (...) {
69886       {
69887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69888       };
69889     }
69890   }
69891 }
69892
69893
69894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69895   void * jresult ;
69896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69897   Dali::Property::Map result;
69898
69899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69900   {
69901     try {
69902       result = (arg1)->GetLayoutProperties();
69903     } catch (std::out_of_range& e) {
69904       {
69905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69906       };
69907     } catch (std::exception& e) {
69908       {
69909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69910       };
69911     } catch (...) {
69912       {
69913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69914       };
69915     }
69916   }
69917   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69918   return jresult;
69919 }
69920
69921
69922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69923   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69924   unsigned int arg2 ;
69925   Dali::Vector3 *arg3 = 0 ;
69926   Dali::Vector3 *arg4 = 0 ;
69927
69928   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69929   arg2 = (unsigned int)jarg2;
69930   arg3 = (Dali::Vector3 *)jarg3;
69931   if (!arg3) {
69932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69933     return ;
69934   }
69935   arg4 = (Dali::Vector3 *)jarg4;
69936   if (!arg4) {
69937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69938     return ;
69939   }
69940   {
69941     try {
69942       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69950       };
69951     } catch (...) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69954       };
69955     }
69956   }
69957 }
69958
69959
69960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69961   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69962   Dali::Vector3 *arg2 = 0 ;
69963
69964   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69965   arg2 = (Dali::Vector3 *)jarg2;
69966   if (!arg2) {
69967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69968     return ;
69969   }
69970   {
69971     try {
69972       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69973     } catch (std::out_of_range& e) {
69974       {
69975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69976       };
69977     } catch (std::exception& e) {
69978       {
69979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69980       };
69981     } catch (...) {
69982       {
69983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69984       };
69985     }
69986   }
69987 }
69988
69989
69990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69991   float jresult ;
69992   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69993   unsigned int arg2 ;
69994   Dali::Vector3 arg3 ;
69995   Dali::Vector3 *argp3 ;
69996   float result;
69997
69998   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69999   arg2 = (unsigned int)jarg2;
70000   argp3 = (Dali::Vector3 *)jarg3;
70001   if (!argp3) {
70002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70003     return 0;
70004   }
70005   arg3 = *argp3;
70006   {
70007     try {
70008       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (...) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70020       };
70021     }
70022   }
70023   jresult = result;
70024   return jresult;
70025 }
70026
70027
70028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
70029   float jresult ;
70030   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70031   float arg2 ;
70032   float result;
70033
70034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70035   arg2 = (float)jarg2;
70036   {
70037     try {
70038       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70039     } catch (std::out_of_range& e) {
70040       {
70041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70042       };
70043     } catch (std::exception& e) {
70044       {
70045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70046       };
70047     } catch (...) {
70048       {
70049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70050       };
70051     }
70052   }
70053   jresult = result;
70054   return jresult;
70055 }
70056
70057
70058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70059   float jresult ;
70060   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70061   unsigned int arg2 ;
70062   float result;
70063
70064   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70065   arg2 = (unsigned int)jarg2;
70066   {
70067     try {
70068       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70069     } catch (std::out_of_range& e) {
70070       {
70071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70072       };
70073     } catch (std::exception& e) {
70074       {
70075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70076       };
70077     } catch (...) {
70078       {
70079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70080       };
70081     }
70082   }
70083   jresult = result;
70084   return jresult;
70085 }
70086
70087
70088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70089   void * jresult ;
70090   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70091   float arg2 ;
70092   Dali::Vector3 arg3 ;
70093   Dali::Vector3 *argp3 ;
70094   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70095
70096   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70097   arg2 = (float)jarg2;
70098   argp3 = (Dali::Vector3 *)jarg3;
70099   if (!argp3) {
70100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70101     return 0;
70102   }
70103   arg3 = *argp3;
70104   {
70105     try {
70106       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70107     } catch (std::out_of_range& e) {
70108       {
70109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (std::exception& e) {
70112       {
70113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (...) {
70116       {
70117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70118       };
70119     }
70120   }
70121   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70122   return jresult;
70123 }
70124
70125
70126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70127   float jresult ;
70128   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70129   int arg2 ;
70130   float arg3 ;
70131   Dali::Vector3 *arg4 = 0 ;
70132   float result;
70133
70134   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70135   arg2 = (int)jarg2;
70136   arg3 = (float)jarg3;
70137   arg4 = (Dali::Vector3 *)jarg4;
70138   if (!arg4) {
70139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70140     return 0;
70141   }
70142   {
70143     try {
70144       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70145     } catch (std::out_of_range& e) {
70146       {
70147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70148       };
70149     } catch (std::exception& e) {
70150       {
70151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70156       };
70157     }
70158   }
70159   jresult = result;
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70165   unsigned int jresult ;
70166   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70167   Dali::Vector3 arg2 ;
70168   Dali::Vector3 *argp2 ;
70169   unsigned int result;
70170
70171   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70172   argp2 = (Dali::Vector3 *)jarg2;
70173   if (!argp2) {
70174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70175     return 0;
70176   }
70177   arg2 = *argp2;
70178   {
70179     try {
70180       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70181     } catch (std::out_of_range& e) {
70182       {
70183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70184       };
70185     } catch (std::exception& e) {
70186       {
70187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70188       };
70189     } catch (...) {
70190       {
70191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70192       };
70193     }
70194   }
70195   jresult = result;
70196   return jresult;
70197 }
70198
70199
70200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70201   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70202   unsigned int arg2 ;
70203   Dali::Vector3 *arg3 = 0 ;
70204   Dali::Vector3 *arg4 = 0 ;
70205
70206   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70207   arg2 = (unsigned int)jarg2;
70208   arg3 = (Dali::Vector3 *)jarg3;
70209   if (!arg3) {
70210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70211     return ;
70212   }
70213   arg4 = (Dali::Vector3 *)jarg4;
70214   if (!arg4) {
70215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70216     return ;
70217   }
70218   {
70219     try {
70220       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70232       };
70233     }
70234   }
70235 }
70236
70237
70238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70239   void * jresult ;
70240   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70241   Dali::Degree result;
70242
70243   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70244   {
70245     try {
70246       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70254       };
70255     } catch (...) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70258       };
70259     }
70260   }
70261   jresult = new Dali::Degree((const Dali::Degree &)result);
70262   return jresult;
70263 }
70264
70265
70266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70267   float jresult ;
70268   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70269   float result;
70270
70271   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70272   {
70273     try {
70274       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70275     } catch (std::out_of_range& e) {
70276       {
70277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70278       };
70279     } catch (std::exception& e) {
70280       {
70281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70282       };
70283     } catch (...) {
70284       {
70285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70286       };
70287     }
70288   }
70289   jresult = result;
70290   return jresult;
70291 }
70292
70293
70294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70295   float jresult ;
70296   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70297   float result;
70298
70299   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70300   {
70301     try {
70302       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70303     } catch (std::out_of_range& e) {
70304       {
70305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70306       };
70307     } catch (std::exception& e) {
70308       {
70309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70310       };
70311     } catch (...) {
70312       {
70313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70314       };
70315     }
70316   }
70317   jresult = result;
70318   return jresult;
70319 }
70320
70321
70322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70323   float jresult ;
70324   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70325   float result;
70326
70327   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70328   {
70329     try {
70330       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70331     } catch (std::out_of_range& e) {
70332       {
70333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70334       };
70335     } catch (std::exception& e) {
70336       {
70337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70338       };
70339     } catch (...) {
70340       {
70341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70342       };
70343     }
70344   }
70345   jresult = result;
70346   return jresult;
70347 }
70348
70349
70350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70351   int jresult ;
70352   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70353   int arg2 ;
70354   int arg3 ;
70355   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70356   bool arg5 ;
70357   int result;
70358
70359   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70360   arg2 = (int)jarg2;
70361   arg3 = (int)jarg3;
70362   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70363   arg5 = jarg5 ? true : false;
70364   {
70365     try {
70366       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70367     } catch (std::out_of_range& e) {
70368       {
70369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70370       };
70371     } catch (std::exception& e) {
70372       {
70373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70374       };
70375     } catch (...) {
70376       {
70377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70378       };
70379     }
70380   }
70381   jresult = result;
70382   return jresult;
70383 }
70384
70385
70386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70387   float jresult ;
70388   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70389   float result;
70390
70391   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70392   {
70393     try {
70394       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70402       };
70403     } catch (...) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70406       };
70407     }
70408   }
70409   jresult = result;
70410   return jresult;
70411 }
70412
70413
70414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70415   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70416   Dali::Actor *arg2 = 0 ;
70417   int arg3 ;
70418   Dali::Vector3 *arg4 = 0 ;
70419   Dali::Actor *arg5 = 0 ;
70420
70421   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70422   arg2 = (Dali::Actor *)jarg2;
70423   if (!arg2) {
70424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70425     return ;
70426   }
70427   arg3 = (int)jarg3;
70428   arg4 = (Dali::Vector3 *)jarg4;
70429   if (!arg4) {
70430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70431     return ;
70432   }
70433   arg5 = (Dali::Actor *)jarg5;
70434   if (!arg5) {
70435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70436     return ;
70437   }
70438   {
70439     try {
70440       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70441     } catch (std::out_of_range& e) {
70442       {
70443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70444       };
70445     } catch (std::exception& e) {
70446       {
70447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70448       };
70449     } catch (...) {
70450       {
70451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70452       };
70453     }
70454   }
70455 }
70456
70457
70458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70459   void * jresult ;
70460   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70461   int arg2 ;
70462   float arg3 ;
70463   Dali::Vector3 *arg4 = 0 ;
70464   Dali::Vector3 result;
70465
70466   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70467   arg2 = (int)jarg2;
70468   arg3 = (float)jarg3;
70469   arg4 = (Dali::Vector3 *)jarg4;
70470   if (!arg4) {
70471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70472     return 0;
70473   }
70474   {
70475     try {
70476       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70477     } catch (std::out_of_range& e) {
70478       {
70479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70480       };
70481     } catch (std::exception& e) {
70482       {
70483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70484       };
70485     } catch (...) {
70486       {
70487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70488       };
70489     }
70490   }
70491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70492   return jresult;
70493 }
70494
70495
70496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70497   void * jresult ;
70498   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70499   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70500
70501   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70502   {
70503     try {
70504       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70505     } catch (std::out_of_range& e) {
70506       {
70507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70508       };
70509     } catch (std::exception& e) {
70510       {
70511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70512       };
70513     } catch (...) {
70514       {
70515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70516       };
70517     }
70518   }
70519   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70520   return jresult;
70521 }
70522
70523
70524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70525   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70526
70527   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70528   {
70529     try {
70530       delete arg1;
70531     } catch (std::out_of_range& e) {
70532       {
70533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70534       };
70535     } catch (std::exception& e) {
70536       {
70537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70538       };
70539     } catch (...) {
70540       {
70541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70542       };
70543     }
70544   }
70545 }
70546
70547
70548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70549   unsigned int jresult ;
70550   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70551   unsigned int result;
70552
70553   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70554   {
70555     try {
70556       result = (unsigned int)(arg1)->GetNumberOfItems();
70557     } catch (std::out_of_range& e) {
70558       {
70559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70560       };
70561     } catch (std::exception& e) {
70562       {
70563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70564       };
70565     } catch (...) {
70566       {
70567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70568       };
70569     }
70570   }
70571   jresult = result;
70572   return jresult;
70573 }
70574
70575
70576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70577   void * jresult ;
70578   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70579   unsigned int arg2 ;
70580   Dali::Actor result;
70581
70582   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70583   arg2 = (unsigned int)jarg2;
70584   {
70585     try {
70586       result = (arg1)->NewItem(arg2);
70587     } catch (std::out_of_range& e) {
70588       {
70589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70590       };
70591     } catch (std::exception& e) {
70592       {
70593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70598       };
70599     }
70600   }
70601   jresult = new Dali::Actor((const Dali::Actor &)result);
70602   return jresult;
70603 }
70604
70605
70606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70607   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70608   unsigned int arg2 ;
70609   Dali::Actor arg3 ;
70610   Dali::Actor *argp3 ;
70611
70612   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70613   arg2 = (unsigned int)jarg2;
70614   argp3 = (Dali::Actor *)jarg3;
70615   if (!argp3) {
70616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70617     return ;
70618   }
70619   arg3 = *argp3;
70620   {
70621     try {
70622       (arg1)->ItemReleased(arg2,arg3);
70623     } catch (std::out_of_range& e) {
70624       {
70625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70626       };
70627     } catch (std::exception& e) {
70628       {
70629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70630       };
70631     } catch (...) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70634       };
70635     }
70636   }
70637 }
70638
70639
70640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70641   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70642   unsigned int arg2 ;
70643   Dali::Actor arg3 ;
70644   Dali::Actor *argp3 ;
70645
70646   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70647   arg2 = (unsigned int)jarg2;
70648   argp3 = (Dali::Actor *)jarg3;
70649   if (!argp3) {
70650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70651     return ;
70652   }
70653   arg3 = *argp3;
70654   {
70655     try {
70656       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70657     } catch (std::out_of_range& e) {
70658       {
70659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70660       };
70661     } catch (std::exception& e) {
70662       {
70663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70668       };
70669     }
70670   }
70671 }
70672
70673
70674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70675   void * jresult ;
70676   Dali::Toolkit::ItemFactory *result = 0 ;
70677
70678   {
70679     try {
70680       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70681     } catch (std::out_of_range& e) {
70682       {
70683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70684       };
70685     } catch (std::exception& e) {
70686       {
70687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70688       };
70689     } catch (...) {
70690       {
70691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70692       };
70693     }
70694   }
70695   jresult = (void *)result;
70696   return jresult;
70697 }
70698
70699
70700 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) {
70701   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70702   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70703   if (director) {
70704     director->swig_connect_director(callback0, callback1, callback2);
70705   }
70706 }
70707
70708
70709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70710   int jresult ;
70711   int result;
70712
70713   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70714   jresult = (int)result;
70715   return jresult;
70716 }
70717
70718
70719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70720   int jresult ;
70721   int result;
70722
70723   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70724   jresult = (int)result;
70725   return jresult;
70726 }
70727
70728
70729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70730   int jresult ;
70731   int result;
70732
70733   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70734   jresult = (int)result;
70735   return jresult;
70736 }
70737
70738
70739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70740   int jresult ;
70741   int result;
70742
70743   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70744   jresult = (int)result;
70745   return jresult;
70746 }
70747
70748
70749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70750   int jresult ;
70751   int result;
70752
70753   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70754   jresult = (int)result;
70755   return jresult;
70756 }
70757
70758
70759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70760   int jresult ;
70761   int result;
70762
70763   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70764   jresult = (int)result;
70765   return jresult;
70766 }
70767
70768
70769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70770   int jresult ;
70771   int result;
70772
70773   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70774   jresult = (int)result;
70775   return jresult;
70776 }
70777
70778
70779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70780   int jresult ;
70781   int result;
70782
70783   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70784   jresult = (int)result;
70785   return jresult;
70786 }
70787
70788
70789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70790   int jresult ;
70791   int result;
70792
70793   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70794   jresult = (int)result;
70795   return jresult;
70796 }
70797
70798
70799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70800   int jresult ;
70801   int result;
70802
70803   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70804   jresult = (int)result;
70805   return jresult;
70806 }
70807
70808
70809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70810   int jresult ;
70811   int result;
70812
70813   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70814   jresult = (int)result;
70815   return jresult;
70816 }
70817
70818
70819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70820   void * jresult ;
70821   Dali::Toolkit::ItemView::Property *result = 0 ;
70822
70823   {
70824     try {
70825       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70826     } catch (std::out_of_range& e) {
70827       {
70828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70829       };
70830     } catch (std::exception& e) {
70831       {
70832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70833       };
70834     } catch (...) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70837       };
70838     }
70839   }
70840   jresult = (void *)result;
70841   return jresult;
70842 }
70843
70844
70845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70846   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70847
70848   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70849   {
70850     try {
70851       delete arg1;
70852     } catch (std::out_of_range& e) {
70853       {
70854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70855       };
70856     } catch (std::exception& e) {
70857       {
70858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70859       };
70860     } catch (...) {
70861       {
70862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70863       };
70864     }
70865   }
70866 }
70867
70868
70869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70870   void * jresult ;
70871   Dali::Toolkit::ItemView *result = 0 ;
70872
70873   {
70874     try {
70875       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70876     } catch (std::out_of_range& e) {
70877       {
70878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70879       };
70880     } catch (std::exception& e) {
70881       {
70882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70883       };
70884     } catch (...) {
70885       {
70886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70887       };
70888     }
70889   }
70890   jresult = (void *)result;
70891   return jresult;
70892 }
70893
70894
70895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70896   void * jresult ;
70897   Dali::Toolkit::ItemView *arg1 = 0 ;
70898   Dali::Toolkit::ItemView *result = 0 ;
70899
70900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70901   if (!arg1) {
70902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70903     return 0;
70904   }
70905   {
70906     try {
70907       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70908     } catch (std::out_of_range& e) {
70909       {
70910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70911       };
70912     } catch (std::exception& e) {
70913       {
70914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70915       };
70916     } catch (...) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70919       };
70920     }
70921   }
70922   jresult = (void *)result;
70923   return jresult;
70924 }
70925
70926
70927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70928   void * jresult ;
70929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70930   Dali::Toolkit::ItemView *arg2 = 0 ;
70931   Dali::Toolkit::ItemView *result = 0 ;
70932
70933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70934   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70935   if (!arg2) {
70936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70937     return 0;
70938   }
70939   {
70940     try {
70941       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70942     } catch (std::out_of_range& e) {
70943       {
70944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70945       };
70946     } catch (std::exception& e) {
70947       {
70948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70949       };
70950     } catch (...) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70953       };
70954     }
70955   }
70956   jresult = (void *)result;
70957   return jresult;
70958 }
70959
70960
70961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70962   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70963
70964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70965   {
70966     try {
70967       delete arg1;
70968     } catch (std::out_of_range& e) {
70969       {
70970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70971       };
70972     } catch (std::exception& e) {
70973       {
70974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (...) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70979       };
70980     }
70981   }
70982 }
70983
70984
70985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70986   void * jresult ;
70987   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70988   Dali::Toolkit::ItemView result;
70989
70990   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70991   if (!arg1) {
70992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70993     return 0;
70994   }
70995   {
70996     try {
70997       result = Dali::Toolkit::ItemView::New(*arg1);
70998     } catch (std::out_of_range& e) {
70999       {
71000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71001       };
71002     } catch (std::exception& e) {
71003       {
71004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71005       };
71006     } catch (...) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71009       };
71010     }
71011   }
71012   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71013   return jresult;
71014 }
71015
71016
71017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
71018   void * jresult ;
71019   Dali::BaseHandle arg1 ;
71020   Dali::BaseHandle *argp1 ;
71021   Dali::Toolkit::ItemView result;
71022
71023   argp1 = (Dali::BaseHandle *)jarg1;
71024   if (!argp1) {
71025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71026     return 0;
71027   }
71028   arg1 = *argp1;
71029   {
71030     try {
71031       result = Dali::Toolkit::ItemView::DownCast(arg1);
71032     } catch (std::out_of_range& e) {
71033       {
71034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71035       };
71036     } catch (std::exception& e) {
71037       {
71038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71039       };
71040     } catch (...) {
71041       {
71042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71043       };
71044     }
71045   }
71046   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71047   return jresult;
71048 }
71049
71050
71051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71052   unsigned int jresult ;
71053   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71054   unsigned int result;
71055
71056   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71057   {
71058     try {
71059       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71060     } catch (std::out_of_range& e) {
71061       {
71062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71063       };
71064     } catch (std::exception& e) {
71065       {
71066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71067       };
71068     } catch (...) {
71069       {
71070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71071       };
71072     }
71073   }
71074   jresult = result;
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71080   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71081   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71082
71083   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71084   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71085   if (!arg2) {
71086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71087     return ;
71088   }
71089   {
71090     try {
71091       (arg1)->AddLayout(*arg2);
71092     } catch (std::out_of_range& e) {
71093       {
71094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71095       };
71096     } catch (std::exception& e) {
71097       {
71098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71099       };
71100     } catch (...) {
71101       {
71102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71103       };
71104     }
71105   }
71106 }
71107
71108
71109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71111   unsigned int arg2 ;
71112
71113   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71114   arg2 = (unsigned int)jarg2;
71115   {
71116     try {
71117       (arg1)->RemoveLayout(arg2);
71118     } catch (std::out_of_range& e) {
71119       {
71120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71121       };
71122     } catch (std::exception& e) {
71123       {
71124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71125       };
71126     } catch (...) {
71127       {
71128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71129       };
71130     }
71131   }
71132 }
71133
71134
71135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71136   void * jresult ;
71137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71138   unsigned int arg2 ;
71139   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71140
71141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71142   arg2 = (unsigned int)jarg2;
71143   {
71144     try {
71145       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71146     } catch (std::out_of_range& e) {
71147       {
71148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71149       };
71150     } catch (std::exception& e) {
71151       {
71152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71153       };
71154     } catch (...) {
71155       {
71156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71157       };
71158     }
71159   }
71160   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71161   return jresult;
71162 }
71163
71164
71165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71166   void * jresult ;
71167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71168   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71169
71170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71171   {
71172     try {
71173       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71174     } catch (std::out_of_range& e) {
71175       {
71176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71177       };
71178     } catch (std::exception& e) {
71179       {
71180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71185       };
71186     }
71187   }
71188   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71189   return jresult;
71190 }
71191
71192
71193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71194   float jresult ;
71195   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71196   Dali::Toolkit::ItemId arg2 ;
71197   float result;
71198
71199   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71200   arg2 = (Dali::Toolkit::ItemId)jarg2;
71201   {
71202     try {
71203       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71204     } catch (std::out_of_range& e) {
71205       {
71206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71207       };
71208     } catch (std::exception& e) {
71209       {
71210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (...) {
71213       {
71214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71215       };
71216     }
71217   }
71218   jresult = result;
71219   return jresult;
71220 }
71221
71222
71223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71225   unsigned int arg2 ;
71226   Dali::Vector3 arg3 ;
71227   float arg4 ;
71228   Dali::Vector3 *argp3 ;
71229
71230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71231   arg2 = (unsigned int)jarg2;
71232   argp3 = (Dali::Vector3 *)jarg3;
71233   if (!argp3) {
71234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71235     return ;
71236   }
71237   arg3 = *argp3;
71238   arg4 = (float)jarg4;
71239   {
71240     try {
71241       (arg1)->ActivateLayout(arg2,arg3,arg4);
71242     } catch (std::out_of_range& e) {
71243       {
71244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71245       };
71246     } catch (std::exception& e) {
71247       {
71248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71249       };
71250     } catch (...) {
71251       {
71252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71253       };
71254     }
71255   }
71256 }
71257
71258
71259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71260   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71261
71262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71263   {
71264     try {
71265       (arg1)->DeactivateCurrentLayout();
71266     } catch (std::out_of_range& e) {
71267       {
71268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71269       };
71270     } catch (std::exception& e) {
71271       {
71272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71273       };
71274     } catch (...) {
71275       {
71276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71277       };
71278     }
71279   }
71280 }
71281
71282
71283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71284   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71285   float arg2 ;
71286
71287   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71288   arg2 = (float)jarg2;
71289   {
71290     try {
71291       (arg1)->SetMinimumSwipeSpeed(arg2);
71292     } catch (std::out_of_range& e) {
71293       {
71294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71295       };
71296     } catch (std::exception& e) {
71297       {
71298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71299       };
71300     } catch (...) {
71301       {
71302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71303       };
71304     }
71305   }
71306 }
71307
71308
71309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71310   float jresult ;
71311   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71312   float result;
71313
71314   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71315   {
71316     try {
71317       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71318     } catch (std::out_of_range& e) {
71319       {
71320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71321       };
71322     } catch (std::exception& e) {
71323       {
71324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71325       };
71326     } catch (...) {
71327       {
71328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71329       };
71330     }
71331   }
71332   jresult = result;
71333   return jresult;
71334 }
71335
71336
71337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71338   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71339   float arg2 ;
71340
71341   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71342   arg2 = (float)jarg2;
71343   {
71344     try {
71345       (arg1)->SetMinimumSwipeDistance(arg2);
71346     } catch (std::out_of_range& e) {
71347       {
71348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71349       };
71350     } catch (std::exception& e) {
71351       {
71352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71353       };
71354     } catch (...) {
71355       {
71356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71357       };
71358     }
71359   }
71360 }
71361
71362
71363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71364   float jresult ;
71365   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71366   float result;
71367
71368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71369   {
71370     try {
71371       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71372     } catch (std::out_of_range& e) {
71373       {
71374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71375       };
71376     } catch (std::exception& e) {
71377       {
71378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71379       };
71380     } catch (...) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71383       };
71384     }
71385   }
71386   jresult = result;
71387   return jresult;
71388 }
71389
71390
71391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71392   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71393   float arg2 ;
71394
71395   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71396   arg2 = (float)jarg2;
71397   {
71398     try {
71399       (arg1)->SetWheelScrollDistanceStep(arg2);
71400     } catch (std::out_of_range& e) {
71401       {
71402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71403       };
71404     } catch (std::exception& e) {
71405       {
71406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71407       };
71408     } catch (...) {
71409       {
71410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71411       };
71412     }
71413   }
71414 }
71415
71416
71417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71418   float jresult ;
71419   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71420   float result;
71421
71422   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71423   {
71424     try {
71425       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71426     } catch (std::out_of_range& e) {
71427       {
71428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71429       };
71430     } catch (std::exception& e) {
71431       {
71432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71437       };
71438     }
71439   }
71440   jresult = result;
71441   return jresult;
71442 }
71443
71444
71445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71447   bool arg2 ;
71448
71449   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71450   arg2 = jarg2 ? true : false;
71451   {
71452     try {
71453       (arg1)->SetAnchoring(arg2);
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71461       };
71462     } catch (...) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71465       };
71466     }
71467   }
71468 }
71469
71470
71471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71472   unsigned int jresult ;
71473   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71474   bool result;
71475
71476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71477   {
71478     try {
71479       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71480     } catch (std::out_of_range& e) {
71481       {
71482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71483       };
71484     } catch (std::exception& e) {
71485       {
71486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71487       };
71488     } catch (...) {
71489       {
71490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71491       };
71492     }
71493   }
71494   jresult = result;
71495   return jresult;
71496 }
71497
71498
71499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71501   float arg2 ;
71502
71503   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71504   arg2 = (float)jarg2;
71505   {
71506     try {
71507       (arg1)->SetAnchoringDuration(arg2);
71508     } catch (std::out_of_range& e) {
71509       {
71510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71511       };
71512     } catch (std::exception& e) {
71513       {
71514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71515       };
71516     } catch (...) {
71517       {
71518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71519       };
71520     }
71521   }
71522 }
71523
71524
71525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71526   float jresult ;
71527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71528   float result;
71529
71530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71531   {
71532     try {
71533       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71545       };
71546     }
71547   }
71548   jresult = result;
71549   return jresult;
71550 }
71551
71552
71553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71554   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71555   Dali::Toolkit::ItemId arg2 ;
71556   float arg3 ;
71557
71558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71559   arg2 = (Dali::Toolkit::ItemId)jarg2;
71560   arg3 = (float)jarg3;
71561   {
71562     try {
71563       (arg1)->ScrollToItem(arg2,arg3);
71564     } catch (std::out_of_range& e) {
71565       {
71566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71567       };
71568     } catch (std::exception& e) {
71569       {
71570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71571       };
71572     } catch (...) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71575       };
71576     }
71577   }
71578 }
71579
71580
71581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71583   float arg2 ;
71584
71585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71586   arg2 = (float)jarg2;
71587   {
71588     try {
71589       (arg1)->SetRefreshInterval(arg2);
71590     } catch (std::out_of_range& e) {
71591       {
71592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71593       };
71594     } catch (std::exception& e) {
71595       {
71596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71597       };
71598     } catch (...) {
71599       {
71600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71601       };
71602     }
71603   }
71604 }
71605
71606
71607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71608   float jresult ;
71609   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71610   float result;
71611
71612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71613   {
71614     try {
71615       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71616     } catch (std::out_of_range& e) {
71617       {
71618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (std::exception& e) {
71621       {
71622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71623       };
71624     } catch (...) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71627       };
71628     }
71629   }
71630   jresult = result;
71631   return jresult;
71632 }
71633
71634
71635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71637
71638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71639   {
71640     try {
71641       (arg1)->Refresh();
71642     } catch (std::out_of_range& e) {
71643       {
71644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71645       };
71646     } catch (std::exception& e) {
71647       {
71648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71649       };
71650     } catch (...) {
71651       {
71652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71653       };
71654     }
71655   }
71656 }
71657
71658
71659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71660   void * jresult ;
71661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71662   Dali::Toolkit::ItemId arg2 ;
71663   Dali::Actor result;
71664
71665   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71666   arg2 = (Dali::Toolkit::ItemId)jarg2;
71667   {
71668     try {
71669       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71670     } catch (std::out_of_range& e) {
71671       {
71672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71673       };
71674     } catch (std::exception& e) {
71675       {
71676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71677       };
71678     } catch (...) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71681       };
71682     }
71683   }
71684   jresult = new Dali::Actor((const Dali::Actor &)result);
71685   return jresult;
71686 }
71687
71688
71689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71690   unsigned int jresult ;
71691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71692   Dali::Actor arg2 ;
71693   Dali::Actor *argp2 ;
71694   Dali::Toolkit::ItemId result;
71695
71696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71697   argp2 = (Dali::Actor *)jarg2;
71698   if (!argp2) {
71699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71700     return 0;
71701   }
71702   arg2 = *argp2;
71703   {
71704     try {
71705       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71706     } catch (std::out_of_range& e) {
71707       {
71708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71709       };
71710     } catch (std::exception& e) {
71711       {
71712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71713       };
71714     } catch (...) {
71715       {
71716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71717       };
71718     }
71719   }
71720   jresult = result;
71721   return jresult;
71722 }
71723
71724
71725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71727   Dali::Toolkit::Item arg2 ;
71728   float arg3 ;
71729   Dali::Toolkit::Item *argp2 ;
71730
71731   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71732   argp2 = (Dali::Toolkit::Item *)jarg2;
71733   if (!argp2) {
71734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71735     return ;
71736   }
71737   arg2 = *argp2;
71738   arg3 = (float)jarg3;
71739   {
71740     try {
71741       (arg1)->InsertItem(arg2,arg3);
71742     } catch (std::out_of_range& e) {
71743       {
71744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71745       };
71746     } catch (std::exception& e) {
71747       {
71748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71749       };
71750     } catch (...) {
71751       {
71752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71753       };
71754     }
71755   }
71756 }
71757
71758
71759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71761   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71762   float arg3 ;
71763
71764   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71765   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71766   if (!arg2) {
71767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71768     return ;
71769   }
71770   arg3 = (float)jarg3;
71771   {
71772     try {
71773       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71774     } catch (std::out_of_range& e) {
71775       {
71776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71777       };
71778     } catch (std::exception& e) {
71779       {
71780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71781       };
71782     } catch (...) {
71783       {
71784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71785       };
71786     }
71787   }
71788 }
71789
71790
71791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71792   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71793   Dali::Toolkit::ItemId arg2 ;
71794   float arg3 ;
71795
71796   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71797   arg2 = (Dali::Toolkit::ItemId)jarg2;
71798   arg3 = (float)jarg3;
71799   {
71800     try {
71801       (arg1)->RemoveItem(arg2,arg3);
71802     } catch (std::out_of_range& e) {
71803       {
71804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71805       };
71806     } catch (std::exception& e) {
71807       {
71808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71809       };
71810     } catch (...) {
71811       {
71812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71813       };
71814     }
71815   }
71816 }
71817
71818
71819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71820   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71821   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71822   float arg3 ;
71823
71824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71825   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71826   if (!arg2) {
71827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71828     return ;
71829   }
71830   arg3 = (float)jarg3;
71831   {
71832     try {
71833       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71834     } catch (std::out_of_range& e) {
71835       {
71836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71837       };
71838     } catch (std::exception& e) {
71839       {
71840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71841       };
71842     } catch (...) {
71843       {
71844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71845       };
71846     }
71847   }
71848 }
71849
71850
71851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71853   Dali::Toolkit::Item arg2 ;
71854   float arg3 ;
71855   Dali::Toolkit::Item *argp2 ;
71856
71857   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71858   argp2 = (Dali::Toolkit::Item *)jarg2;
71859   if (!argp2) {
71860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71861     return ;
71862   }
71863   arg2 = *argp2;
71864   arg3 = (float)jarg3;
71865   {
71866     try {
71867       (arg1)->ReplaceItem(arg2,arg3);
71868     } catch (std::out_of_range& e) {
71869       {
71870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71871       };
71872     } catch (std::exception& e) {
71873       {
71874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71875       };
71876     } catch (...) {
71877       {
71878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71879       };
71880     }
71881   }
71882 }
71883
71884
71885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71886   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71887   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71888   float arg3 ;
71889
71890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71891   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71892   if (!arg2) {
71893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71894     return ;
71895   }
71896   arg3 = (float)jarg3;
71897   {
71898     try {
71899       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71900     } catch (std::out_of_range& e) {
71901       {
71902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71903       };
71904     } catch (std::exception& e) {
71905       {
71906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71907       };
71908     } catch (...) {
71909       {
71910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71911       };
71912     }
71913   }
71914 }
71915
71916
71917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71918   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71919   Dali::Vector3 *arg2 = 0 ;
71920
71921   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71922   arg2 = (Dali::Vector3 *)jarg2;
71923   if (!arg2) {
71924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71925     return ;
71926   }
71927   {
71928     try {
71929       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71930     } catch (std::out_of_range& e) {
71931       {
71932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (std::exception& e) {
71935       {
71936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71941       };
71942     }
71943   }
71944 }
71945
71946
71947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71948   void * jresult ;
71949   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71950   Dali::Vector3 result;
71951
71952   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71953   {
71954     try {
71955       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71956     } catch (std::out_of_range& e) {
71957       {
71958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71959       };
71960     } catch (std::exception& e) {
71961       {
71962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71963       };
71964     } catch (...) {
71965       {
71966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71967       };
71968     }
71969   }
71970   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71971   return jresult;
71972 }
71973
71974
71975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71976   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71977   Dali::Vector3 *arg2 = 0 ;
71978
71979   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71980   arg2 = (Dali::Vector3 *)jarg2;
71981   if (!arg2) {
71982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71983     return ;
71984   }
71985   {
71986     try {
71987       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71988     } catch (std::out_of_range& e) {
71989       {
71990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71991       };
71992     } catch (std::exception& e) {
71993       {
71994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71995       };
71996     } catch (...) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71999       };
72000     }
72001   }
72002 }
72003
72004
72005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72006   void * jresult ;
72007   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72008   Dali::Vector3 result;
72009
72010   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72011   {
72012     try {
72013       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72014     } catch (std::out_of_range& e) {
72015       {
72016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72017       };
72018     } catch (std::exception& e) {
72019       {
72020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72021       };
72022     } catch (...) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72025       };
72026     }
72027   }
72028   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72029   return jresult;
72030 }
72031
72032
72033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72035   Dali::Toolkit::ItemRange *arg2 = 0 ;
72036
72037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72038   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72039   if (!arg2) {
72040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72041     return ;
72042   }
72043   {
72044     try {
72045       (arg1)->GetItemsRange(*arg2);
72046     } catch (std::out_of_range& e) {
72047       {
72048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72049       };
72050     } catch (std::exception& e) {
72051       {
72052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72053       };
72054     } catch (...) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72057       };
72058     }
72059   }
72060 }
72061
72062
72063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72064   void * jresult ;
72065   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72066   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72067
72068   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72069   {
72070     try {
72071       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72072     } catch (std::out_of_range& e) {
72073       {
72074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72075       };
72076     } catch (std::exception& e) {
72077       {
72078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72079       };
72080     } catch (...) {
72081       {
72082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72083       };
72084     }
72085   }
72086   jresult = (void *)result;
72087   return jresult;
72088 }
72089
72090
72091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72092   Dali::Vector3 *arg1 = 0 ;
72093   PropertyInputContainer *arg2 = 0 ;
72094
72095   arg1 = (Dali::Vector3 *)jarg1;
72096   if (!arg1) {
72097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72098     return ;
72099   }
72100   arg2 = (PropertyInputContainer *)jarg2;
72101   if (!arg2) {
72102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72103     return ;
72104   }
72105   {
72106     try {
72107       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72115       };
72116     } catch (...) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72119       };
72120     }
72121   }
72122 }
72123
72124
72125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72126   Dali::Vector3 *arg1 = 0 ;
72127   PropertyInputContainer *arg2 = 0 ;
72128
72129   arg1 = (Dali::Vector3 *)jarg1;
72130   if (!arg1) {
72131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72132     return ;
72133   }
72134   arg2 = (PropertyInputContainer *)jarg2;
72135   if (!arg2) {
72136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72137     return ;
72138   }
72139   {
72140     try {
72141       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72142     } catch (std::out_of_range& e) {
72143       {
72144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72145       };
72146     } catch (std::exception& e) {
72147       {
72148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72149       };
72150     } catch (...) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72153       };
72154     }
72155   }
72156 }
72157
72158
72159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72160   void * jresult ;
72161   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72162
72163   {
72164     try {
72165       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72166     } catch (std::out_of_range& e) {
72167       {
72168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72169       };
72170     } catch (std::exception& e) {
72171       {
72172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72173       };
72174     } catch (...) {
72175       {
72176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72177       };
72178     }
72179   }
72180   jresult = (void *)result;
72181   return jresult;
72182 }
72183
72184
72185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72186   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72187
72188   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72189   {
72190     try {
72191       delete arg1;
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72203       };
72204     }
72205   }
72206 }
72207
72208
72209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72210   void * jresult ;
72211   Dali::Path arg1 ;
72212   Dali::Vector3 *arg2 = 0 ;
72213   Dali::Property::Index arg3 ;
72214   Dali::Vector3 *arg4 = 0 ;
72215   unsigned int arg5 ;
72216   Dali::Path *argp1 ;
72217   Dali::Toolkit::ScrollViewPagePathEffect result;
72218
72219   argp1 = (Dali::Path *)jarg1;
72220   if (!argp1) {
72221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72222     return 0;
72223   }
72224   arg1 = *argp1;
72225   arg2 = (Dali::Vector3 *)jarg2;
72226   if (!arg2) {
72227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72228     return 0;
72229   }
72230   arg3 = (Dali::Property::Index)jarg3;
72231   arg4 = (Dali::Vector3 *)jarg4;
72232   if (!arg4) {
72233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72234     return 0;
72235   }
72236   arg5 = (unsigned int)jarg5;
72237   {
72238     try {
72239       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72240     } catch (std::out_of_range& e) {
72241       {
72242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72243       };
72244     } catch (std::exception& e) {
72245       {
72246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (...) {
72249       {
72250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72251       };
72252     }
72253   }
72254   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72255   return jresult;
72256 }
72257
72258
72259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72260   void * jresult ;
72261   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72262
72263   {
72264     try {
72265       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72266     } catch (std::out_of_range& e) {
72267       {
72268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72269       };
72270     } catch (std::exception& e) {
72271       {
72272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72273       };
72274     } catch (...) {
72275       {
72276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72277       };
72278     }
72279   }
72280   jresult = (void *)result;
72281   return jresult;
72282 }
72283
72284
72285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72286   void * jresult ;
72287   Dali::BaseHandle arg1 ;
72288   Dali::BaseHandle *argp1 ;
72289   Dali::Toolkit::ScrollViewPagePathEffect result;
72290
72291   argp1 = (Dali::BaseHandle *)jarg1;
72292   if (!argp1) {
72293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72294     return 0;
72295   }
72296   arg1 = *argp1;
72297   {
72298     try {
72299       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72300     } catch (std::out_of_range& e) {
72301       {
72302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72303       };
72304     } catch (std::exception& e) {
72305       {
72306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72307       };
72308     } catch (...) {
72309       {
72310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72311       };
72312     }
72313   }
72314   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72315   return jresult;
72316 }
72317
72318
72319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72320   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72321   Dali::Actor arg2 ;
72322   unsigned int arg3 ;
72323   Dali::Actor *argp2 ;
72324
72325   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72326   argp2 = (Dali::Actor *)jarg2;
72327   if (!argp2) {
72328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72329     return ;
72330   }
72331   arg2 = *argp2;
72332   arg3 = (unsigned int)jarg3;
72333   {
72334     try {
72335       (arg1)->ApplyToPage(arg2,arg3);
72336     } catch (std::out_of_range& e) {
72337       {
72338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72339       };
72340     } catch (std::exception& e) {
72341       {
72342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72343       };
72344     } catch (...) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72347       };
72348     }
72349   }
72350 }
72351
72352
72353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72354   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72355
72356   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72357   {
72358     try {
72359       delete arg1;
72360     } catch (std::out_of_range& e) {
72361       {
72362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72363       };
72364     } catch (std::exception& e) {
72365       {
72366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (...) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72371       };
72372     }
72373   }
72374 }
72375
72376
72377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x = arg2;
72384 }
72385
72386
72387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x);
72394   jresult = (int)result;
72395   return jresult;
72396 }
72397
72398
72399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72400   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72401   Dali::Toolkit::ClampState arg2 ;
72402
72403   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72404   arg2 = (Dali::Toolkit::ClampState)jarg2;
72405   if (arg1) (arg1)->y = arg2;
72406 }
72407
72408
72409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72410   int jresult ;
72411   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72412   Dali::Toolkit::ClampState result;
72413
72414   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72415   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72416   jresult = (int)result;
72417   return jresult;
72418 }
72419
72420
72421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72422   void * jresult ;
72423   Dali::Toolkit::ClampState2D *result = 0 ;
72424
72425   {
72426     try {
72427       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72428     } catch (std::out_of_range& e) {
72429       {
72430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72431       };
72432     } catch (std::exception& e) {
72433       {
72434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72435       };
72436     } catch (...) {
72437       {
72438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72439       };
72440     }
72441   }
72442   jresult = (void *)result;
72443   return jresult;
72444 }
72445
72446
72447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72448   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72449
72450   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72451   {
72452     try {
72453       delete arg1;
72454     } catch (std::out_of_range& e) {
72455       {
72456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72457       };
72458     } catch (std::exception& e) {
72459       {
72460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72461       };
72462     } catch (...) {
72463       {
72464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72465       };
72466     }
72467   }
72468 }
72469
72470
72471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72472   void * jresult ;
72473   float arg1 ;
72474   float arg2 ;
72475   bool arg3 ;
72476   Dali::Toolkit::RulerDomain *result = 0 ;
72477
72478   arg1 = (float)jarg1;
72479   arg2 = (float)jarg2;
72480   arg3 = jarg3 ? true : false;
72481   {
72482     try {
72483       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72484     } catch (std::out_of_range& e) {
72485       {
72486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72487       };
72488     } catch (std::exception& e) {
72489       {
72490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72491       };
72492     } catch (...) {
72493       {
72494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72495       };
72496     }
72497   }
72498   jresult = (void *)result;
72499   return jresult;
72500 }
72501
72502
72503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72504   void * jresult ;
72505   float arg1 ;
72506   float arg2 ;
72507   Dali::Toolkit::RulerDomain *result = 0 ;
72508
72509   arg1 = (float)jarg1;
72510   arg2 = (float)jarg2;
72511   {
72512     try {
72513       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72514     } catch (std::out_of_range& e) {
72515       {
72516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72517       };
72518     } catch (std::exception& e) {
72519       {
72520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72525       };
72526     }
72527   }
72528   jresult = (void *)result;
72529   return jresult;
72530 }
72531
72532
72533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min = arg2;
72540 }
72541
72542
72543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min);
72550   jresult = result;
72551   return jresult;
72552 }
72553
72554
72555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72556   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72557   float arg2 ;
72558
72559   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72560   arg2 = (float)jarg2;
72561   if (arg1) (arg1)->max = arg2;
72562 }
72563
72564
72565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72566   float jresult ;
72567   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72568   float result;
72569
72570   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72571   result = (float) ((arg1)->max);
72572   jresult = result;
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72578   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72579   bool arg2 ;
72580
72581   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72582   arg2 = jarg2 ? true : false;
72583   if (arg1) (arg1)->enabled = arg2;
72584 }
72585
72586
72587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72588   unsigned int jresult ;
72589   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72590   bool result;
72591
72592   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72593   result = (bool) ((arg1)->enabled);
72594   jresult = result;
72595   return jresult;
72596 }
72597
72598
72599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72600   float jresult ;
72601   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72602   float arg2 ;
72603   float arg3 ;
72604   float arg4 ;
72605   float result;
72606
72607   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72608   arg2 = (float)jarg2;
72609   arg3 = (float)jarg3;
72610   arg4 = (float)jarg4;
72611   {
72612     try {
72613       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72614     } catch (std::out_of_range& e) {
72615       {
72616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72617       };
72618     } catch (std::exception& e) {
72619       {
72620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72621       };
72622     } catch (...) {
72623       {
72624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72625       };
72626     }
72627   }
72628   jresult = result;
72629   return jresult;
72630 }
72631
72632
72633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72634   float jresult ;
72635   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72636   float arg2 ;
72637   float arg3 ;
72638   float result;
72639
72640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72641   arg2 = (float)jarg2;
72642   arg3 = (float)jarg3;
72643   {
72644     try {
72645       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72646     } catch (std::out_of_range& e) {
72647       {
72648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72649       };
72650     } catch (std::exception& e) {
72651       {
72652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72653       };
72654     } catch (...) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72657       };
72658     }
72659   }
72660   jresult = result;
72661   return jresult;
72662 }
72663
72664
72665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72666   float jresult ;
72667   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72668   float arg2 ;
72669   float result;
72670
72671   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72672   arg2 = (float)jarg2;
72673   {
72674     try {
72675       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72676     } catch (std::out_of_range& e) {
72677       {
72678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72679       };
72680     } catch (std::exception& e) {
72681       {
72682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72683       };
72684     } catch (...) {
72685       {
72686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72687       };
72688     }
72689   }
72690   jresult = result;
72691   return jresult;
72692 }
72693
72694
72695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72696   float jresult ;
72697   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72698   float arg2 ;
72699   float arg3 ;
72700   float arg4 ;
72701   Dali::Toolkit::ClampState *arg5 = 0 ;
72702   float result;
72703
72704   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72705   arg2 = (float)jarg2;
72706   arg3 = (float)jarg3;
72707   arg4 = (float)jarg4;
72708   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72709   if (!arg5) {
72710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72711     return 0;
72712   }
72713   {
72714     try {
72715       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72727       };
72728     }
72729   }
72730   jresult = result;
72731   return jresult;
72732 }
72733
72734
72735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72736   float jresult ;
72737   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72738   float result;
72739
72740   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72741   {
72742     try {
72743       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72744     } catch (std::out_of_range& e) {
72745       {
72746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72747       };
72748     } catch (std::exception& e) {
72749       {
72750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72751       };
72752     } catch (...) {
72753       {
72754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72755       };
72756     }
72757   }
72758   jresult = result;
72759   return jresult;
72760 }
72761
72762
72763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72764   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72765
72766   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72767   {
72768     try {
72769       delete arg1;
72770     } catch (std::out_of_range& e) {
72771       {
72772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72773       };
72774     } catch (std::exception& e) {
72775       {
72776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72777       };
72778     } catch (...) {
72779       {
72780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72781       };
72782     }
72783   }
72784 }
72785
72786
72787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72788   float jresult ;
72789   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72790   float arg2 ;
72791   float arg3 ;
72792   float result;
72793
72794   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72795   arg2 = (float)jarg2;
72796   arg3 = (float)jarg3;
72797   {
72798     try {
72799       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72800     } catch (std::out_of_range& e) {
72801       {
72802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72803       };
72804     } catch (std::exception& e) {
72805       {
72806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72807       };
72808     } catch (...) {
72809       {
72810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72811       };
72812     }
72813   }
72814   jresult = result;
72815   return jresult;
72816 }
72817
72818
72819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72820   float jresult ;
72821   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72822   float arg2 ;
72823   float result;
72824
72825   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72826   arg2 = (float)jarg2;
72827   {
72828     try {
72829       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72830     } catch (std::out_of_range& e) {
72831       {
72832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72833       };
72834     } catch (std::exception& e) {
72835       {
72836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72837       };
72838     } catch (...) {
72839       {
72840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72841       };
72842     }
72843   }
72844   jresult = result;
72845   return jresult;
72846 }
72847
72848
72849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72850   float jresult ;
72851   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72852   unsigned int arg2 ;
72853   unsigned int *arg3 = 0 ;
72854   bool arg4 ;
72855   float result;
72856
72857   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72858   arg2 = (unsigned int)jarg2;
72859   arg3 = (unsigned int *)jarg3;
72860   arg4 = jarg4 ? true : false;
72861   {
72862     try {
72863       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72864     } catch (std::out_of_range& e) {
72865       {
72866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72867       };
72868     } catch (std::exception& e) {
72869       {
72870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72871       };
72872     } catch (...) {
72873       {
72874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72875       };
72876     }
72877   }
72878   jresult = result;
72879   return jresult;
72880 }
72881
72882
72883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72884   unsigned int jresult ;
72885   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72886   float arg2 ;
72887   bool arg3 ;
72888   unsigned int result;
72889
72890   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72891   arg2 = (float)jarg2;
72892   arg3 = jarg3 ? true : false;
72893   {
72894     try {
72895       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72896     } catch (std::out_of_range& e) {
72897       {
72898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72899       };
72900     } catch (std::exception& e) {
72901       {
72902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72903       };
72904     } catch (...) {
72905       {
72906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72907       };
72908     }
72909   }
72910   jresult = result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72916   unsigned int jresult ;
72917   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72918   unsigned int result;
72919
72920   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72921   {
72922     try {
72923       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72924     } catch (std::out_of_range& e) {
72925       {
72926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72927       };
72928     } catch (std::exception& e) {
72929       {
72930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72931       };
72932     } catch (...) {
72933       {
72934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72935       };
72936     }
72937   }
72938   jresult = result;
72939   return jresult;
72940 }
72941
72942
72943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72944   int jresult ;
72945   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72946   Dali::Toolkit::Ruler::RulerType result;
72947
72948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72949   {
72950     try {
72951       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72952     } catch (std::out_of_range& e) {
72953       {
72954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72955       };
72956     } catch (std::exception& e) {
72957       {
72958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (...) {
72961       {
72962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72963       };
72964     }
72965   }
72966   jresult = (int)result;
72967   return jresult;
72968 }
72969
72970
72971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72972   unsigned int jresult ;
72973   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72974   bool result;
72975
72976   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72977   {
72978     try {
72979       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72980     } catch (std::out_of_range& e) {
72981       {
72982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72983       };
72984     } catch (std::exception& e) {
72985       {
72986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72987       };
72988     } catch (...) {
72989       {
72990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72991       };
72992     }
72993   }
72994   jresult = result;
72995   return jresult;
72996 }
72997
72998
72999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73000   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73001
73002   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73003   {
73004     try {
73005       (arg1)->Enable();
73006     } catch (std::out_of_range& e) {
73007       {
73008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73009       };
73010     } catch (std::exception& e) {
73011       {
73012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73013       };
73014     } catch (...) {
73015       {
73016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73017       };
73018     }
73019   }
73020 }
73021
73022
73023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73024   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73025
73026   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73027   {
73028     try {
73029       (arg1)->Disable();
73030     } catch (std::out_of_range& e) {
73031       {
73032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73033       };
73034     } catch (std::exception& e) {
73035       {
73036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73037       };
73038     } catch (...) {
73039       {
73040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73041       };
73042     }
73043   }
73044 }
73045
73046
73047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73048   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73049   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73050   Dali::Toolkit::RulerDomain *argp2 ;
73051
73052   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73053   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73054   if (!argp2) {
73055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73056     return ;
73057   }
73058   arg2 = *argp2;
73059   {
73060     try {
73061       (arg1)->SetDomain(arg2);
73062     } catch (std::out_of_range& e) {
73063       {
73064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73065       };
73066     } catch (std::exception& e) {
73067       {
73068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73069       };
73070     } catch (...) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73073       };
73074     }
73075   }
73076 }
73077
73078
73079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73080   void * jresult ;
73081   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73082   Dali::Toolkit::RulerDomain *result = 0 ;
73083
73084   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73085   {
73086     try {
73087       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73088     } catch (std::out_of_range& e) {
73089       {
73090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73091       };
73092     } catch (std::exception& e) {
73093       {
73094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73095       };
73096     } catch (...) {
73097       {
73098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73099       };
73100     }
73101   }
73102   jresult = (void *)result;
73103   return jresult;
73104 }
73105
73106
73107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73108   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73109
73110   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73111   {
73112     try {
73113       (arg1)->DisableDomain();
73114     } catch (std::out_of_range& e) {
73115       {
73116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73117       };
73118     } catch (std::exception& e) {
73119       {
73120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73121       };
73122     } catch (...) {
73123       {
73124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73125       };
73126     }
73127   }
73128 }
73129
73130
73131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73132   float jresult ;
73133   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73134   float arg2 ;
73135   float arg3 ;
73136   float arg4 ;
73137   float result;
73138
73139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73140   arg2 = (float)jarg2;
73141   arg3 = (float)jarg3;
73142   arg4 = (float)jarg4;
73143   {
73144     try {
73145       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73146     } catch (std::out_of_range& e) {
73147       {
73148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73149       };
73150     } catch (std::exception& e) {
73151       {
73152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73153       };
73154     } catch (...) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73157       };
73158     }
73159   }
73160   jresult = result;
73161   return jresult;
73162 }
73163
73164
73165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73166   float jresult ;
73167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73168   float arg2 ;
73169   float arg3 ;
73170   float result;
73171
73172   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73173   arg2 = (float)jarg2;
73174   arg3 = (float)jarg3;
73175   {
73176     try {
73177       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73178     } catch (std::out_of_range& e) {
73179       {
73180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73181       };
73182     } catch (std::exception& e) {
73183       {
73184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (...) {
73187       {
73188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73189       };
73190     }
73191   }
73192   jresult = result;
73193   return jresult;
73194 }
73195
73196
73197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73198   float jresult ;
73199   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73200   float arg2 ;
73201   float result;
73202
73203   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73204   arg2 = (float)jarg2;
73205   {
73206     try {
73207       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73208     } catch (std::out_of_range& e) {
73209       {
73210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73211       };
73212     } catch (std::exception& e) {
73213       {
73214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73215       };
73216     } catch (...) {
73217       {
73218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73219       };
73220     }
73221   }
73222   jresult = result;
73223   return jresult;
73224 }
73225
73226
73227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73228   float jresult ;
73229   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73230   float arg2 ;
73231   float arg3 ;
73232   float arg4 ;
73233   Dali::Toolkit::ClampState *arg5 = 0 ;
73234   float result;
73235
73236   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73237   arg2 = (float)jarg2;
73238   arg3 = (float)jarg3;
73239   arg4 = (float)jarg4;
73240   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73241   if (!arg5) {
73242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73243     return 0;
73244   }
73245   {
73246     try {
73247       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (...) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73259       };
73260     }
73261   }
73262   jresult = result;
73263   return jresult;
73264 }
73265
73266
73267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73268   float jresult ;
73269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73270   float arg2 ;
73271   float arg3 ;
73272   float arg4 ;
73273   float arg5 ;
73274   float result;
73275
73276   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73277   arg2 = (float)jarg2;
73278   arg3 = (float)jarg3;
73279   arg4 = (float)jarg4;
73280   arg5 = (float)jarg5;
73281   {
73282     try {
73283       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (...) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73295       };
73296     }
73297   }
73298   jresult = result;
73299   return jresult;
73300 }
73301
73302
73303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73304   float jresult ;
73305   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73306   float arg2 ;
73307   float arg3 ;
73308   float arg4 ;
73309   float result;
73310
73311   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73312   arg2 = (float)jarg2;
73313   arg3 = (float)jarg3;
73314   arg4 = (float)jarg4;
73315   {
73316     try {
73317       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73318     } catch (std::out_of_range& e) {
73319       {
73320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73321       };
73322     } catch (std::exception& e) {
73323       {
73324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73325       };
73326     } catch (...) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73329       };
73330     }
73331   }
73332   jresult = result;
73333   return jresult;
73334 }
73335
73336
73337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73338   float jresult ;
73339   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73340   float arg2 ;
73341   float arg3 ;
73342   float result;
73343
73344   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73345   arg2 = (float)jarg2;
73346   arg3 = (float)jarg3;
73347   {
73348     try {
73349       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73350     } catch (std::out_of_range& e) {
73351       {
73352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73353       };
73354     } catch (std::exception& e) {
73355       {
73356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (...) {
73359       {
73360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73361       };
73362     }
73363   }
73364   jresult = result;
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73370   float jresult ;
73371   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73372   float arg2 ;
73373   float result;
73374
73375   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73376   arg2 = (float)jarg2;
73377   {
73378     try {
73379       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73380     } catch (std::out_of_range& e) {
73381       {
73382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (std::exception& e) {
73385       {
73386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73387       };
73388     } catch (...) {
73389       {
73390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73391       };
73392     }
73393   }
73394   jresult = result;
73395   return jresult;
73396 }
73397
73398
73399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73400   float jresult ;
73401   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73402   float arg2 ;
73403   float arg3 ;
73404   float arg4 ;
73405   float arg5 ;
73406   Dali::Toolkit::ClampState *arg6 = 0 ;
73407   float result;
73408
73409   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73410   arg2 = (float)jarg2;
73411   arg3 = (float)jarg3;
73412   arg4 = (float)jarg4;
73413   arg5 = (float)jarg5;
73414   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73415   if (!arg6) {
73416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73417     return 0;
73418   }
73419   {
73420     try {
73421       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73422     } catch (std::out_of_range& e) {
73423       {
73424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (std::exception& e) {
73427       {
73428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (...) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73433       };
73434     }
73435   }
73436   jresult = result;
73437   return jresult;
73438 }
73439
73440
73441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73442   void * jresult ;
73443   Dali::Toolkit::DefaultRuler *result = 0 ;
73444
73445   {
73446     try {
73447       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73448     } catch (std::out_of_range& e) {
73449       {
73450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73451       };
73452     } catch (std::exception& e) {
73453       {
73454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73455       };
73456     } catch (...) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73459       };
73460     }
73461   }
73462   jresult = (void *)result;
73463   return jresult;
73464 }
73465
73466
73467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73468   float jresult ;
73469   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73470   float arg2 ;
73471   float arg3 ;
73472   float result;
73473
73474   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73475   arg2 = (float)jarg2;
73476   arg3 = (float)jarg3;
73477   {
73478     try {
73479       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73480     } catch (std::out_of_range& e) {
73481       {
73482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73483       };
73484     } catch (std::exception& e) {
73485       {
73486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73487       };
73488     } catch (...) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73491       };
73492     }
73493   }
73494   jresult = result;
73495   return jresult;
73496 }
73497
73498
73499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73500   float jresult ;
73501   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73502   unsigned int arg2 ;
73503   unsigned int *arg3 = 0 ;
73504   bool arg4 ;
73505   float result;
73506
73507   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73508   arg2 = (unsigned int)jarg2;
73509   arg3 = (unsigned int *)jarg3;
73510   arg4 = jarg4 ? true : false;
73511   {
73512     try {
73513       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73514     } catch (std::out_of_range& e) {
73515       {
73516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73517       };
73518     } catch (std::exception& e) {
73519       {
73520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73521       };
73522     } catch (...) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73525       };
73526     }
73527   }
73528   jresult = result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73534   unsigned int jresult ;
73535   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73536   float arg2 ;
73537   bool arg3 ;
73538   unsigned int result;
73539
73540   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73541   arg2 = (float)jarg2;
73542   arg3 = jarg3 ? true : false;
73543   {
73544     try {
73545       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73546     } catch (std::out_of_range& e) {
73547       {
73548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73549       };
73550     } catch (std::exception& e) {
73551       {
73552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73557       };
73558     }
73559   }
73560   jresult = result;
73561   return jresult;
73562 }
73563
73564
73565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73566   unsigned int jresult ;
73567   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73568   unsigned int result;
73569
73570   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73571   {
73572     try {
73573       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73574     } catch (std::out_of_range& e) {
73575       {
73576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73577       };
73578     } catch (std::exception& e) {
73579       {
73580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73581       };
73582     } catch (...) {
73583       {
73584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73585       };
73586     }
73587   }
73588   jresult = result;
73589   return jresult;
73590 }
73591
73592
73593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73594   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73595
73596   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73597   {
73598     try {
73599       delete arg1;
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73607       };
73608     } catch (...) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73611       };
73612     }
73613   }
73614 }
73615
73616
73617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73618   void * jresult ;
73619   float arg1 ;
73620   Dali::Toolkit::FixedRuler *result = 0 ;
73621
73622   arg1 = (float)jarg1;
73623   {
73624     try {
73625       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73626     } catch (std::out_of_range& e) {
73627       {
73628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73629       };
73630     } catch (std::exception& e) {
73631       {
73632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73633       };
73634     } catch (...) {
73635       {
73636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73637       };
73638     }
73639   }
73640   jresult = (void *)result;
73641   return jresult;
73642 }
73643
73644
73645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73646   void * jresult ;
73647   Dali::Toolkit::FixedRuler *result = 0 ;
73648
73649   {
73650     try {
73651       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73652     } catch (std::out_of_range& e) {
73653       {
73654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73655       };
73656     } catch (std::exception& e) {
73657       {
73658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73659       };
73660     } catch (...) {
73661       {
73662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73663       };
73664     }
73665   }
73666   jresult = (void *)result;
73667   return jresult;
73668 }
73669
73670
73671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73672   float jresult ;
73673   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73674   float arg2 ;
73675   float arg3 ;
73676   float result;
73677
73678   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73679   arg2 = (float)jarg2;
73680   arg3 = (float)jarg3;
73681   {
73682     try {
73683       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73684     } catch (std::out_of_range& e) {
73685       {
73686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73687       };
73688     } catch (std::exception& e) {
73689       {
73690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73691       };
73692     } catch (...) {
73693       {
73694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73695       };
73696     }
73697   }
73698   jresult = result;
73699   return jresult;
73700 }
73701
73702
73703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73704   float jresult ;
73705   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73706   unsigned int arg2 ;
73707   unsigned int *arg3 = 0 ;
73708   bool arg4 ;
73709   float result;
73710
73711   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73712   arg2 = (unsigned int)jarg2;
73713   arg3 = (unsigned int *)jarg3;
73714   arg4 = jarg4 ? true : false;
73715   {
73716     try {
73717       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73718     } catch (std::out_of_range& e) {
73719       {
73720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73721       };
73722     } catch (std::exception& e) {
73723       {
73724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73725       };
73726     } catch (...) {
73727       {
73728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73729       };
73730     }
73731   }
73732   jresult = result;
73733   return jresult;
73734 }
73735
73736
73737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73738   unsigned int jresult ;
73739   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73740   float arg2 ;
73741   bool arg3 ;
73742   unsigned int result;
73743
73744   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73745   arg2 = (float)jarg2;
73746   arg3 = jarg3 ? true : false;
73747   {
73748     try {
73749       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73750     } catch (std::out_of_range& e) {
73751       {
73752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73753       };
73754     } catch (std::exception& e) {
73755       {
73756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73757       };
73758     } catch (...) {
73759       {
73760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73761       };
73762     }
73763   }
73764   jresult = result;
73765   return jresult;
73766 }
73767
73768
73769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73770   unsigned int jresult ;
73771   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73772   unsigned int result;
73773
73774   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73775   {
73776     try {
73777       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73778     } catch (std::out_of_range& e) {
73779       {
73780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73781       };
73782     } catch (std::exception& e) {
73783       {
73784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73789       };
73790     }
73791   }
73792   jresult = result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73798   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73799
73800   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73801   {
73802     try {
73803       delete arg1;
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73811       };
73812     } catch (...) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73815       };
73816     }
73817   }
73818 }
73819
73820
73821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale = *arg2;
73828 }
73829
73830
73831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale);
73838   jresult = (void *)result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73844   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73845   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73846
73847   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73848   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73849   if (arg1) (arg1)->position = *arg2;
73850 }
73851
73852
73853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73854   void * jresult ;
73855   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73856   Dali::Toolkit::ClampState2D *result = 0 ;
73857
73858   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73859   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73860   jresult = (void *)result;
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73866   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73867   Dali::Toolkit::ClampState arg2 ;
73868
73869   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73870   arg2 = (Dali::Toolkit::ClampState)jarg2;
73871   if (arg1) (arg1)->rotation = arg2;
73872 }
73873
73874
73875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73876   int jresult ;
73877   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73878   Dali::Toolkit::ClampState result;
73879
73880   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73881   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73882   jresult = (int)result;
73883   return jresult;
73884 }
73885
73886
73887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73888   void * jresult ;
73889   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73890
73891   {
73892     try {
73893       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73894     } catch (std::out_of_range& e) {
73895       {
73896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (std::exception& e) {
73899       {
73900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908   jresult = (void *)result;
73909   return jresult;
73910 }
73911
73912
73913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73914   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73915
73916   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73917   {
73918     try {
73919       delete arg1;
73920     } catch (std::out_of_range& e) {
73921       {
73922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73923       };
73924     } catch (std::exception& e) {
73925       {
73926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73927       };
73928     } catch (...) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73931       };
73932     }
73933   }
73934 }
73935
73936
73937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73938   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73939   Dali::Toolkit::SnapType arg2 ;
73940
73941   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73942   arg2 = (Dali::Toolkit::SnapType)jarg2;
73943   if (arg1) (arg1)->type = arg2;
73944 }
73945
73946
73947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73948   int jresult ;
73949   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73950   Dali::Toolkit::SnapType result;
73951
73952   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73953   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73954   jresult = (int)result;
73955   return jresult;
73956 }
73957
73958
73959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73960   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73961   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73962
73963   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73964   arg2 = (Dali::Vector2 *)jarg2;
73965   if (arg1) (arg1)->position = *arg2;
73966 }
73967
73968
73969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73970   void * jresult ;
73971   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73972   Dali::Vector2 *result = 0 ;
73973
73974   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73975   result = (Dali::Vector2 *)& ((arg1)->position);
73976   jresult = (void *)result;
73977   return jresult;
73978 }
73979
73980
73981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73982   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73983   float arg2 ;
73984
73985   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73986   arg2 = (float)jarg2;
73987   if (arg1) (arg1)->duration = arg2;
73988 }
73989
73990
73991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73992   float jresult ;
73993   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73994   float result;
73995
73996   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73997   result = (float) ((arg1)->duration);
73998   jresult = result;
73999   return jresult;
74000 }
74001
74002
74003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74004   void * jresult ;
74005   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74006
74007   {
74008     try {
74009       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74010     } catch (std::out_of_range& e) {
74011       {
74012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (std::exception& e) {
74015       {
74016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (...) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74021       };
74022     }
74023   }
74024   jresult = (void *)result;
74025   return jresult;
74026 }
74027
74028
74029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74030   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74031
74032   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74033   {
74034     try {
74035       delete arg1;
74036     } catch (std::out_of_range& e) {
74037       {
74038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74039       };
74040     } catch (std::exception& e) {
74041       {
74042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74043       };
74044     } catch (...) {
74045       {
74046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74047       };
74048     }
74049   }
74050 }
74051
74052
74053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74054   int jresult ;
74055   int result;
74056
74057   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74058   jresult = (int)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74064   int jresult ;
74065   int result;
74066
74067   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74068   jresult = (int)result;
74069   return jresult;
74070 }
74071
74072
74073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74074   int jresult ;
74075   int result;
74076
74077   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74078   jresult = (int)result;
74079   return jresult;
74080 }
74081
74082
74083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74084   int jresult ;
74085   int result;
74086
74087   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74088   jresult = (int)result;
74089   return jresult;
74090 }
74091
74092
74093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74094   int jresult ;
74095   int result;
74096
74097   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
74098   jresult = (int)result;
74099   return jresult;
74100 }
74101
74102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74103   int jresult ;
74104   int result;
74105
74106   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74107   jresult = (int)result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74113   int jresult ;
74114   int result;
74115
74116   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74117   jresult = (int)result;
74118   return jresult;
74119 }
74120
74121
74122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74123   int jresult ;
74124   int result;
74125
74126   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74127   jresult = (int)result;
74128   return jresult;
74129 }
74130
74131
74132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74133   int jresult ;
74134   int result;
74135
74136   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74137   jresult = (int)result;
74138   return jresult;
74139 }
74140
74141
74142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74143   int jresult ;
74144   int result;
74145
74146   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74147   jresult = (int)result;
74148   return jresult;
74149 }
74150
74151
74152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74153   int jresult ;
74154   int result;
74155
74156   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74157   jresult = (int)result;
74158   return jresult;
74159 }
74160
74161
74162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74163   int jresult ;
74164   int result;
74165
74166   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74167   jresult = (int)result;
74168   return jresult;
74169 }
74170
74171
74172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74173   int jresult ;
74174   int result;
74175
74176   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74177   jresult = (int)result;
74178   return jresult;
74179 }
74180
74181
74182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74183   int jresult ;
74184   int result;
74185
74186   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74187   jresult = (int)result;
74188   return jresult;
74189 }
74190
74191
74192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74193   int jresult ;
74194   int result;
74195
74196   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74197   jresult = (int)result;
74198   return jresult;
74199 }
74200
74201
74202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74203   int jresult ;
74204   int result;
74205
74206   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74207   jresult = (int)result;
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74213   int jresult ;
74214   int result;
74215
74216   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74217   jresult = (int)result;
74218   return jresult;
74219 }
74220
74221
74222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74223   int jresult ;
74224   int result;
74225
74226   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74227   jresult = (int)result;
74228   return jresult;
74229 }
74230
74231
74232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74233   int jresult ;
74234   int result;
74235
74236   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74237   jresult = (int)result;
74238   return jresult;
74239 }
74240
74241
74242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74243   int jresult ;
74244   int result;
74245
74246   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74247   jresult = (int)result;
74248   return jresult;
74249 }
74250
74251
74252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74253   int jresult ;
74254   int result;
74255
74256   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74257   jresult = (int)result;
74258   return jresult;
74259 }
74260
74261
74262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74263   int jresult ;
74264   int result;
74265
74266   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74267   jresult = (int)result;
74268   return jresult;
74269 }
74270
74271
74272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74273   int jresult ;
74274   int result;
74275
74276   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74277   jresult = (int)result;
74278   return jresult;
74279 }
74280
74281
74282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74283   int jresult ;
74284   int result;
74285
74286   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74287   jresult = (int)result;
74288   return jresult;
74289 }
74290
74291
74292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74293   int jresult ;
74294   int result;
74295
74296   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74297   jresult = (int)result;
74298   return jresult;
74299 }
74300
74301
74302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74303   int jresult ;
74304   int result;
74305
74306   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74307   jresult = (int)result;
74308   return jresult;
74309 }
74310
74311
74312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74313   void * jresult ;
74314   Dali::Toolkit::ScrollView::Property *result = 0 ;
74315
74316   {
74317     try {
74318       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74319     } catch (std::out_of_range& e) {
74320       {
74321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74322       };
74323     } catch (std::exception& e) {
74324       {
74325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74326       };
74327     } catch (...) {
74328       {
74329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74330       };
74331     }
74332   }
74333   jresult = (void *)result;
74334   return jresult;
74335 }
74336
74337
74338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74339   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74340
74341   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74342   {
74343     try {
74344       delete arg1;
74345     } catch (std::out_of_range& e) {
74346       {
74347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74348       };
74349     } catch (std::exception& e) {
74350       {
74351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74356       };
74357     }
74358   }
74359 }
74360
74361
74362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74363   void * jresult ;
74364   Dali::Toolkit::ScrollView *result = 0 ;
74365
74366   {
74367     try {
74368       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74369     } catch (std::out_of_range& e) {
74370       {
74371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74372       };
74373     } catch (std::exception& e) {
74374       {
74375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74376       };
74377     } catch (...) {
74378       {
74379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74380       };
74381     }
74382   }
74383   jresult = (void *)result;
74384   return jresult;
74385 }
74386
74387
74388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74389   void * jresult ;
74390   Dali::Toolkit::ScrollView *arg1 = 0 ;
74391   Dali::Toolkit::ScrollView *result = 0 ;
74392
74393   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74394   if (!arg1) {
74395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74396     return 0;
74397   }
74398   {
74399     try {
74400       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74401     } catch (std::out_of_range& e) {
74402       {
74403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74404       };
74405     } catch (std::exception& e) {
74406       {
74407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74408       };
74409     } catch (...) {
74410       {
74411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74412       };
74413     }
74414   }
74415   jresult = (void *)result;
74416   return jresult;
74417 }
74418
74419
74420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74421   void * jresult ;
74422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74423   Dali::Toolkit::ScrollView *arg2 = 0 ;
74424   Dali::Toolkit::ScrollView *result = 0 ;
74425
74426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74427   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74428   if (!arg2) {
74429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74430     return 0;
74431   }
74432   {
74433     try {
74434       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74435     } catch (std::out_of_range& e) {
74436       {
74437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74438       };
74439     } catch (std::exception& e) {
74440       {
74441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74442       };
74443     } catch (...) {
74444       {
74445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74446       };
74447     }
74448   }
74449   jresult = (void *)result;
74450   return jresult;
74451 }
74452
74453
74454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74456
74457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74458   {
74459     try {
74460       delete arg1;
74461     } catch (std::out_of_range& e) {
74462       {
74463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74464       };
74465     } catch (std::exception& e) {
74466       {
74467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74468       };
74469     } catch (...) {
74470       {
74471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74472       };
74473     }
74474   }
74475 }
74476
74477
74478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74479   void * jresult ;
74480   Dali::Toolkit::ScrollView result;
74481
74482   {
74483     try {
74484       result = Dali::Toolkit::ScrollView::New();
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (...) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74496       };
74497     }
74498   }
74499   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74500   return jresult;
74501 }
74502
74503
74504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74505   void * jresult ;
74506   Dali::BaseHandle arg1 ;
74507   Dali::BaseHandle *argp1 ;
74508   Dali::Toolkit::ScrollView result;
74509
74510   argp1 = (Dali::BaseHandle *)jarg1;
74511   if (!argp1) {
74512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74513     return 0;
74514   }
74515   arg1 = *argp1;
74516   {
74517     try {
74518       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74519     } catch (std::out_of_range& e) {
74520       {
74521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74522       };
74523     } catch (std::exception& e) {
74524       {
74525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74530       };
74531     }
74532   }
74533   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74534   return jresult;
74535 }
74536
74537
74538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74539   void * jresult ;
74540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74541   Dali::AlphaFunction result;
74542
74543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74544   {
74545     try {
74546       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (...) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74558       };
74559     }
74560   }
74561   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74562   return jresult;
74563 }
74564
74565
74566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74568   Dali::AlphaFunction arg2 ;
74569   Dali::AlphaFunction *argp2 ;
74570
74571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74572   argp2 = (Dali::AlphaFunction *)jarg2;
74573   if (!argp2) {
74574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74575     return ;
74576   }
74577   arg2 = *argp2;
74578   {
74579     try {
74580       (arg1)->SetScrollSnapAlphaFunction(arg2);
74581     } catch (std::out_of_range& e) {
74582       {
74583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74584       };
74585     } catch (std::exception& e) {
74586       {
74587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74588       };
74589     } catch (...) {
74590       {
74591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74592       };
74593     }
74594   }
74595 }
74596
74597
74598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74599   void * jresult ;
74600   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74601   Dali::AlphaFunction result;
74602
74603   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74604   {
74605     try {
74606       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74607     } catch (std::out_of_range& e) {
74608       {
74609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74610       };
74611     } catch (std::exception& e) {
74612       {
74613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74614       };
74615     } catch (...) {
74616       {
74617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74618       };
74619     }
74620   }
74621   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74622   return jresult;
74623 }
74624
74625
74626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74628   Dali::AlphaFunction arg2 ;
74629   Dali::AlphaFunction *argp2 ;
74630
74631   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74632   argp2 = (Dali::AlphaFunction *)jarg2;
74633   if (!argp2) {
74634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74635     return ;
74636   }
74637   arg2 = *argp2;
74638   {
74639     try {
74640       (arg1)->SetScrollFlickAlphaFunction(arg2);
74641     } catch (std::out_of_range& e) {
74642       {
74643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74644       };
74645     } catch (std::exception& e) {
74646       {
74647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74648       };
74649     } catch (...) {
74650       {
74651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74652       };
74653     }
74654   }
74655 }
74656
74657
74658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74659   float jresult ;
74660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74661   float result;
74662
74663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74664   {
74665     try {
74666       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74667     } catch (std::out_of_range& e) {
74668       {
74669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74670       };
74671     } catch (std::exception& e) {
74672       {
74673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74674       };
74675     } catch (...) {
74676       {
74677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74678       };
74679     }
74680   }
74681   jresult = result;
74682   return jresult;
74683 }
74684
74685
74686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74687   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74688   float arg2 ;
74689
74690   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74691   arg2 = (float)jarg2;
74692   {
74693     try {
74694       (arg1)->SetScrollSnapDuration(arg2);
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74706       };
74707     }
74708   }
74709 }
74710
74711
74712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74713   float jresult ;
74714   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74715   float result;
74716
74717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74718   {
74719     try {
74720       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74721     } catch (std::out_of_range& e) {
74722       {
74723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (std::exception& e) {
74726       {
74727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74728       };
74729     } catch (...) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74732       };
74733     }
74734   }
74735   jresult = result;
74736   return jresult;
74737 }
74738
74739
74740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74742   float arg2 ;
74743
74744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74745   arg2 = (float)jarg2;
74746   {
74747     try {
74748       (arg1)->SetScrollFlickDuration(arg2);
74749     } catch (std::out_of_range& e) {
74750       {
74751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74752       };
74753     } catch (std::exception& e) {
74754       {
74755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74756       };
74757     } catch (...) {
74758       {
74759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74760       };
74761     }
74762   }
74763 }
74764
74765
74766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74767   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74768   Dali::Toolkit::RulerPtr arg2 ;
74769   Dali::Toolkit::RulerPtr *argp2 ;
74770
74771   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74772   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74773   if (!argp2) {
74774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74775     return ;
74776   }
74777   arg2 = *argp2;
74778   {
74779     try {
74780       (arg1)->SetRulerX(arg2);
74781     } catch (std::out_of_range& e) {
74782       {
74783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74784       };
74785     } catch (std::exception& e) {
74786       {
74787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74792       };
74793     }
74794   }
74795 }
74796
74797
74798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74800   Dali::Toolkit::RulerPtr arg2 ;
74801   Dali::Toolkit::RulerPtr *argp2 ;
74802
74803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74804   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74805   if (!argp2) {
74806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74807     return ;
74808   }
74809   arg2 = *argp2;
74810   {
74811     try {
74812       (arg1)->SetRulerY(arg2);
74813     } catch (std::out_of_range& e) {
74814       {
74815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74816       };
74817     } catch (std::exception& e) {
74818       {
74819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74824       };
74825     }
74826   }
74827 }
74828
74829
74830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74832   bool arg2 ;
74833
74834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74835   arg2 = jarg2 ? true : false;
74836   {
74837     try {
74838       (arg1)->SetScrollSensitive(arg2);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74846       };
74847     } catch (...) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74850       };
74851     }
74852   }
74853 }
74854
74855
74856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74857   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74858   float arg2 ;
74859   float arg3 ;
74860
74861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74862   arg2 = (float)jarg2;
74863   arg3 = (float)jarg3;
74864   {
74865     try {
74866       (arg1)->SetMaxOvershoot(arg2,arg3);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74878       };
74879     }
74880   }
74881 }
74882
74883
74884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74886   Dali::AlphaFunction arg2 ;
74887   Dali::AlphaFunction *argp2 ;
74888
74889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74890   argp2 = (Dali::AlphaFunction *)jarg2;
74891   if (!argp2) {
74892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74893     return ;
74894   }
74895   arg2 = *argp2;
74896   {
74897     try {
74898       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74899     } catch (std::out_of_range& e) {
74900       {
74901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74902       };
74903     } catch (std::exception& e) {
74904       {
74905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74910       };
74911     }
74912   }
74913 }
74914
74915
74916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74918   float arg2 ;
74919
74920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74921   arg2 = (float)jarg2;
74922   {
74923     try {
74924       (arg1)->SetSnapOvershootDuration(arg2);
74925     } catch (std::out_of_range& e) {
74926       {
74927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74928       };
74929     } catch (std::exception& e) {
74930       {
74931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74932       };
74933     } catch (...) {
74934       {
74935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74936       };
74937     }
74938   }
74939 }
74940
74941
74942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74944   bool arg2 ;
74945
74946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74947   arg2 = jarg2 ? true : false;
74948   {
74949     try {
74950       (arg1)->SetActorAutoSnap(arg2);
74951     } catch (std::out_of_range& e) {
74952       {
74953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74954       };
74955     } catch (std::exception& e) {
74956       {
74957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (...) {
74960       {
74961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74962       };
74963     }
74964   }
74965 }
74966
74967
74968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74969   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74970   bool arg2 ;
74971
74972   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74973   arg2 = jarg2 ? true : false;
74974   {
74975     try {
74976       (arg1)->SetWrapMode(arg2);
74977     } catch (std::out_of_range& e) {
74978       {
74979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74980       };
74981     } catch (std::exception& e) {
74982       {
74983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74984       };
74985     } catch (...) {
74986       {
74987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74988       };
74989     }
74990   }
74991 }
74992
74993
74994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74995   int jresult ;
74996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74997   int result;
74998
74999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75000   {
75001     try {
75002       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75003     } catch (std::out_of_range& e) {
75004       {
75005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75006       };
75007     } catch (std::exception& e) {
75008       {
75009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75010       };
75011     } catch (...) {
75012       {
75013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75014       };
75015     }
75016   }
75017   jresult = result;
75018   return jresult;
75019 }
75020
75021
75022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75024   int arg2 ;
75025
75026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75027   arg2 = (int)jarg2;
75028   {
75029     try {
75030       (arg1)->SetScrollUpdateDistance(arg2);
75031     } catch (std::out_of_range& e) {
75032       {
75033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75034       };
75035     } catch (std::exception& e) {
75036       {
75037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75038       };
75039     } catch (...) {
75040       {
75041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75042       };
75043     }
75044   }
75045 }
75046
75047
75048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75049   unsigned int jresult ;
75050   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75051   bool result;
75052
75053   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75054   {
75055     try {
75056       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75057     } catch (std::out_of_range& e) {
75058       {
75059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75060       };
75061     } catch (std::exception& e) {
75062       {
75063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75064       };
75065     } catch (...) {
75066       {
75067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75068       };
75069     }
75070   }
75071   jresult = result;
75072   return jresult;
75073 }
75074
75075
75076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75078   bool arg2 ;
75079
75080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75081   arg2 = jarg2 ? true : false;
75082   {
75083     try {
75084       (arg1)->SetAxisAutoLock(arg2);
75085     } catch (std::out_of_range& e) {
75086       {
75087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75088       };
75089     } catch (std::exception& e) {
75090       {
75091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75092       };
75093     } catch (...) {
75094       {
75095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75096       };
75097     }
75098   }
75099 }
75100
75101
75102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75103   float jresult ;
75104   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75105   float result;
75106
75107   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75108   {
75109     try {
75110       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75111     } catch (std::out_of_range& e) {
75112       {
75113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75114       };
75115     } catch (std::exception& e) {
75116       {
75117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75118       };
75119     } catch (...) {
75120       {
75121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75122       };
75123     }
75124   }
75125   jresult = result;
75126   return jresult;
75127 }
75128
75129
75130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75132   float arg2 ;
75133
75134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75135   arg2 = (float)jarg2;
75136   {
75137     try {
75138       (arg1)->SetAxisAutoLockGradient(arg2);
75139     } catch (std::out_of_range& e) {
75140       {
75141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75142       };
75143     } catch (std::exception& e) {
75144       {
75145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75146       };
75147     } catch (...) {
75148       {
75149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75150       };
75151     }
75152   }
75153 }
75154
75155
75156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75157   float jresult ;
75158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75159   float result;
75160
75161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75162   {
75163     try {
75164       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75165     } catch (std::out_of_range& e) {
75166       {
75167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75168       };
75169     } catch (std::exception& e) {
75170       {
75171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75172       };
75173     } catch (...) {
75174       {
75175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75176       };
75177     }
75178   }
75179   jresult = result;
75180   return jresult;
75181 }
75182
75183
75184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75186   float arg2 ;
75187
75188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75189   arg2 = (float)jarg2;
75190   {
75191     try {
75192       (arg1)->SetFrictionCoefficient(arg2);
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75200       };
75201     } catch (...) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75204       };
75205     }
75206   }
75207 }
75208
75209
75210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75211   float jresult ;
75212   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75213   float result;
75214
75215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75216   {
75217     try {
75218       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75219     } catch (std::out_of_range& e) {
75220       {
75221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (std::exception& e) {
75224       {
75225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233   jresult = result;
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75240   float arg2 ;
75241
75242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75243   arg2 = (float)jarg2;
75244   {
75245     try {
75246       (arg1)->SetFlickSpeedCoefficient(arg2);
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75254       };
75255     } catch (...) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75258       };
75259     }
75260   }
75261 }
75262
75263
75264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75265   void * jresult ;
75266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75267   Dali::Vector2 result;
75268
75269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75270   {
75271     try {
75272       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75273     } catch (std::out_of_range& e) {
75274       {
75275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75276       };
75277     } catch (std::exception& e) {
75278       {
75279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75280       };
75281     } catch (...) {
75282       {
75283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75284       };
75285     }
75286   }
75287   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75288   return jresult;
75289 }
75290
75291
75292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75293   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75294   Dali::Vector2 *arg2 = 0 ;
75295
75296   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75297   arg2 = (Dali::Vector2 *)jarg2;
75298   if (!arg2) {
75299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75300     return ;
75301   }
75302   {
75303     try {
75304       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75305     } catch (std::out_of_range& e) {
75306       {
75307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75308       };
75309     } catch (std::exception& e) {
75310       {
75311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75312       };
75313     } catch (...) {
75314       {
75315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75316       };
75317     }
75318   }
75319 }
75320
75321
75322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75323   float jresult ;
75324   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75325   float result;
75326
75327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75328   {
75329     try {
75330       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75331     } catch (std::out_of_range& e) {
75332       {
75333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75334       };
75335     } catch (std::exception& e) {
75336       {
75337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75338       };
75339     } catch (...) {
75340       {
75341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75342       };
75343     }
75344   }
75345   jresult = result;
75346   return jresult;
75347 }
75348
75349
75350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75352   float arg2 ;
75353
75354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75355   arg2 = (float)jarg2;
75356   {
75357     try {
75358       (arg1)->SetMinimumSpeedForFlick(arg2);
75359     } catch (std::out_of_range& e) {
75360       {
75361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75362       };
75363     } catch (std::exception& e) {
75364       {
75365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75366       };
75367     } catch (...) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75370       };
75371     }
75372   }
75373 }
75374
75375
75376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75377   float jresult ;
75378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75379   float result;
75380
75381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75382   {
75383     try {
75384       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (...) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75396       };
75397     }
75398   }
75399   jresult = result;
75400   return jresult;
75401 }
75402
75403
75404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75406   float arg2 ;
75407
75408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75409   arg2 = (float)jarg2;
75410   {
75411     try {
75412       (arg1)->SetMaxFlickSpeed(arg2);
75413     } catch (std::out_of_range& e) {
75414       {
75415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75416       };
75417     } catch (std::exception& e) {
75418       {
75419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75420       };
75421     } catch (...) {
75422       {
75423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75424       };
75425     }
75426   }
75427 }
75428
75429
75430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75431   void * jresult ;
75432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75433   Dali::Vector2 result;
75434
75435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75436   {
75437     try {
75438       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75439     } catch (std::out_of_range& e) {
75440       {
75441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75442       };
75443     } catch (std::exception& e) {
75444       {
75445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75446       };
75447     } catch (...) {
75448       {
75449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75450       };
75451     }
75452   }
75453   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75454   return jresult;
75455 }
75456
75457
75458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75460   Dali::Vector2 arg2 ;
75461   Dali::Vector2 *argp2 ;
75462
75463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75464   argp2 = (Dali::Vector2 *)jarg2;
75465   if (!argp2) {
75466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75467     return ;
75468   }
75469   arg2 = *argp2;
75470   {
75471     try {
75472       (arg1)->SetWheelScrollDistanceStep(arg2);
75473     } catch (std::out_of_range& e) {
75474       {
75475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75476       };
75477     } catch (std::exception& e) {
75478       {
75479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75480       };
75481     } catch (...) {
75482       {
75483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75484       };
75485     }
75486   }
75487 }
75488
75489
75490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75491   void * jresult ;
75492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75493   Dali::Vector2 result;
75494
75495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75496   {
75497     try {
75498       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75499     } catch (std::out_of_range& e) {
75500       {
75501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75502       };
75503     } catch (std::exception& e) {
75504       {
75505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75506       };
75507     } catch (...) {
75508       {
75509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75510       };
75511     }
75512   }
75513   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75514   return jresult;
75515 }
75516
75517
75518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75519   unsigned int jresult ;
75520   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75521   unsigned int result;
75522
75523   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75524   {
75525     try {
75526       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75527     } catch (std::out_of_range& e) {
75528       {
75529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75530       };
75531     } catch (std::exception& e) {
75532       {
75533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75534       };
75535     } catch (...) {
75536       {
75537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75538       };
75539     }
75540   }
75541   jresult = result;
75542   return jresult;
75543 }
75544
75545
75546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75548   Dali::Vector2 *arg2 = 0 ;
75549
75550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75551   arg2 = (Dali::Vector2 *)jarg2;
75552   if (!arg2) {
75553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75554     return ;
75555   }
75556   {
75557     try {
75558       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75559     } catch (std::out_of_range& e) {
75560       {
75561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75562       };
75563     } catch (std::exception& e) {
75564       {
75565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75566       };
75567     } catch (...) {
75568       {
75569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75570       };
75571     }
75572   }
75573 }
75574
75575
75576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75577   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75578   Dali::Vector2 *arg2 = 0 ;
75579   float arg3 ;
75580
75581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75582   arg2 = (Dali::Vector2 *)jarg2;
75583   if (!arg2) {
75584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75585     return ;
75586   }
75587   arg3 = (float)jarg3;
75588   {
75589     try {
75590       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75591     } catch (std::out_of_range& e) {
75592       {
75593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75594       };
75595     } catch (std::exception& e) {
75596       {
75597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75598       };
75599     } catch (...) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75602       };
75603     }
75604   }
75605 }
75606
75607
75608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75610   Dali::Vector2 *arg2 = 0 ;
75611   float arg3 ;
75612   Dali::AlphaFunction arg4 ;
75613   Dali::AlphaFunction *argp4 ;
75614
75615   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75616   arg2 = (Dali::Vector2 *)jarg2;
75617   if (!arg2) {
75618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75619     return ;
75620   }
75621   arg3 = (float)jarg3;
75622   argp4 = (Dali::AlphaFunction *)jarg4;
75623   if (!argp4) {
75624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75625     return ;
75626   }
75627   arg4 = *argp4;
75628   {
75629     try {
75630       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75642       };
75643     }
75644   }
75645 }
75646
75647
75648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75650   Dali::Vector2 *arg2 = 0 ;
75651   float arg3 ;
75652   Dali::Toolkit::DirectionBias arg4 ;
75653   Dali::Toolkit::DirectionBias arg5 ;
75654
75655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75656   arg2 = (Dali::Vector2 *)jarg2;
75657   if (!arg2) {
75658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75659     return ;
75660   }
75661   arg3 = (float)jarg3;
75662   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75663   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75664   {
75665     try {
75666       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75667     } catch (std::out_of_range& e) {
75668       {
75669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75670       };
75671     } catch (std::exception& e) {
75672       {
75673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75678       };
75679     }
75680   }
75681 }
75682
75683
75684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75686   Dali::Vector2 *arg2 = 0 ;
75687   float arg3 ;
75688   Dali::AlphaFunction arg4 ;
75689   Dali::Toolkit::DirectionBias arg5 ;
75690   Dali::Toolkit::DirectionBias arg6 ;
75691   Dali::AlphaFunction *argp4 ;
75692
75693   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75694   arg2 = (Dali::Vector2 *)jarg2;
75695   if (!arg2) {
75696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75697     return ;
75698   }
75699   arg3 = (float)jarg3;
75700   argp4 = (Dali::AlphaFunction *)jarg4;
75701   if (!argp4) {
75702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75703     return ;
75704   }
75705   arg4 = *argp4;
75706   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75707   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75708   {
75709     try {
75710       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75711     } catch (std::out_of_range& e) {
75712       {
75713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75714       };
75715     } catch (std::exception& e) {
75716       {
75717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75718       };
75719     } catch (...) {
75720       {
75721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75722       };
75723     }
75724   }
75725 }
75726
75727
75728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75729   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75730   unsigned int arg2 ;
75731
75732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75733   arg2 = (unsigned int)jarg2;
75734   {
75735     try {
75736       (arg1)->ScrollTo(arg2);
75737     } catch (std::out_of_range& e) {
75738       {
75739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75740       };
75741     } catch (std::exception& e) {
75742       {
75743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75744       };
75745     } catch (...) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75748       };
75749     }
75750   }
75751 }
75752
75753
75754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75755   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75756   unsigned int arg2 ;
75757   float arg3 ;
75758
75759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75760   arg2 = (unsigned int)jarg2;
75761   arg3 = (float)jarg3;
75762   {
75763     try {
75764       (arg1)->ScrollTo(arg2,arg3);
75765     } catch (std::out_of_range& e) {
75766       {
75767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75768       };
75769     } catch (std::exception& e) {
75770       {
75771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75772       };
75773     } catch (...) {
75774       {
75775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75776       };
75777     }
75778   }
75779 }
75780
75781
75782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75784   unsigned int arg2 ;
75785   float arg3 ;
75786   Dali::Toolkit::DirectionBias arg4 ;
75787
75788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75789   arg2 = (unsigned int)jarg2;
75790   arg3 = (float)jarg3;
75791   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75792   {
75793     try {
75794       (arg1)->ScrollTo(arg2,arg3,arg4);
75795     } catch (std::out_of_range& e) {
75796       {
75797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75798       };
75799     } catch (std::exception& e) {
75800       {
75801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75802       };
75803     } catch (...) {
75804       {
75805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75806       };
75807     }
75808   }
75809 }
75810
75811
75812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75813   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75814   Dali::Actor *arg2 = 0 ;
75815
75816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75817   arg2 = (Dali::Actor *)jarg2;
75818   if (!arg2) {
75819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75820     return ;
75821   }
75822   {
75823     try {
75824       (arg1)->ScrollTo(*arg2);
75825     } catch (std::out_of_range& e) {
75826       {
75827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75828       };
75829     } catch (std::exception& e) {
75830       {
75831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75832       };
75833     } catch (...) {
75834       {
75835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75836       };
75837     }
75838   }
75839 }
75840
75841
75842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75844   Dali::Actor *arg2 = 0 ;
75845   float arg3 ;
75846
75847   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75848   arg2 = (Dali::Actor *)jarg2;
75849   if (!arg2) {
75850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75851     return ;
75852   }
75853   arg3 = (float)jarg3;
75854   {
75855     try {
75856       (arg1)->ScrollTo(*arg2,arg3);
75857     } catch (std::out_of_range& e) {
75858       {
75859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75860       };
75861     } catch (std::exception& e) {
75862       {
75863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (...) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75868       };
75869     }
75870   }
75871 }
75872
75873
75874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75875   unsigned int jresult ;
75876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75877   bool result;
75878
75879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75880   {
75881     try {
75882       result = (bool)(arg1)->ScrollToSnapPoint();
75883     } catch (std::out_of_range& e) {
75884       {
75885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75886       };
75887     } catch (std::exception& e) {
75888       {
75889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75890       };
75891     } catch (...) {
75892       {
75893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75894       };
75895     }
75896   }
75897   jresult = result;
75898   return jresult;
75899 }
75900
75901
75902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75904   Dali::Constraint arg2 ;
75905   Dali::Constraint *argp2 ;
75906
75907   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75908   argp2 = (Dali::Constraint *)jarg2;
75909   if (!argp2) {
75910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75911     return ;
75912   }
75913   arg2 = *argp2;
75914   {
75915     try {
75916       (arg1)->ApplyConstraintToChildren(arg2);
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75928       };
75929     }
75930   }
75931 }
75932
75933
75934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75936
75937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75938   {
75939     try {
75940       (arg1)->RemoveConstraintsFromChildren();
75941     } catch (std::out_of_range& e) {
75942       {
75943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75944       };
75945     } catch (std::exception& e) {
75946       {
75947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75948       };
75949     } catch (...) {
75950       {
75951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75952       };
75953     }
75954   }
75955 }
75956
75957
75958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75960   Dali::Toolkit::ScrollViewEffect arg2 ;
75961   Dali::Toolkit::ScrollViewEffect *argp2 ;
75962
75963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75964   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75965   if (!argp2) {
75966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75967     return ;
75968   }
75969   arg2 = *argp2;
75970   {
75971     try {
75972       (arg1)->ApplyEffect(arg2);
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75980       };
75981     } catch (...) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75984       };
75985     }
75986   }
75987 }
75988
75989
75990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75992   Dali::Toolkit::ScrollViewEffect arg2 ;
75993   Dali::Toolkit::ScrollViewEffect *argp2 ;
75994
75995   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75996   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75997   if (!argp2) {
75998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75999     return ;
76000   }
76001   arg2 = *argp2;
76002   {
76003     try {
76004       (arg1)->RemoveEffect(arg2);
76005     } catch (std::out_of_range& e) {
76006       {
76007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76008       };
76009     } catch (std::exception& e) {
76010       {
76011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (...) {
76014       {
76015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76016       };
76017     }
76018   }
76019 }
76020
76021
76022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76024
76025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76026   {
76027     try {
76028       (arg1)->RemoveAllEffects();
76029     } catch (std::out_of_range& e) {
76030       {
76031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76032       };
76033     } catch (std::exception& e) {
76034       {
76035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76036       };
76037     } catch (...) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76040       };
76041     }
76042   }
76043 }
76044
76045
76046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76048   Dali::Actor arg2 ;
76049   Dali::Actor *argp2 ;
76050
76051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76052   argp2 = (Dali::Actor *)jarg2;
76053   if (!argp2) {
76054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76055     return ;
76056   }
76057   arg2 = *argp2;
76058   {
76059     try {
76060       (arg1)->BindActor(arg2);
76061     } catch (std::out_of_range& e) {
76062       {
76063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76064       };
76065     } catch (std::exception& e) {
76066       {
76067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76068       };
76069     } catch (...) {
76070       {
76071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76072       };
76073     }
76074   }
76075 }
76076
76077
76078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76079   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76080   Dali::Actor arg2 ;
76081   Dali::Actor *argp2 ;
76082
76083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76084   argp2 = (Dali::Actor *)jarg2;
76085   if (!argp2) {
76086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76087     return ;
76088   }
76089   arg2 = *argp2;
76090   {
76091     try {
76092       (arg1)->UnbindActor(arg2);
76093     } catch (std::out_of_range& e) {
76094       {
76095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76096       };
76097     } catch (std::exception& e) {
76098       {
76099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76100       };
76101     } catch (...) {
76102       {
76103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76104       };
76105     }
76106   }
76107 }
76108
76109
76110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76111   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76112   Dali::Radian arg2 ;
76113   Dali::Radian arg3 ;
76114   Dali::Radian *argp2 ;
76115   Dali::Radian *argp3 ;
76116
76117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76118   argp2 = (Dali::Radian *)jarg2;
76119   if (!argp2) {
76120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76121     return ;
76122   }
76123   arg2 = *argp2;
76124   argp3 = (Dali::Radian *)jarg3;
76125   if (!argp3) {
76126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76127     return ;
76128   }
76129   arg3 = *argp3;
76130   {
76131     try {
76132       (arg1)->SetScrollingDirection(arg2,arg3);
76133     } catch (std::out_of_range& e) {
76134       {
76135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76136       };
76137     } catch (std::exception& e) {
76138       {
76139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76140       };
76141     } catch (...) {
76142       {
76143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76144       };
76145     }
76146   }
76147 }
76148
76149
76150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76152   Dali::Radian arg2 ;
76153   Dali::Radian *argp2 ;
76154
76155   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76156   argp2 = (Dali::Radian *)jarg2;
76157   if (!argp2) {
76158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76159     return ;
76160   }
76161   arg2 = *argp2;
76162   {
76163     try {
76164       (arg1)->SetScrollingDirection(arg2);
76165     } catch (std::out_of_range& e) {
76166       {
76167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (std::exception& e) {
76170       {
76171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76172       };
76173     } catch (...) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76176       };
76177     }
76178   }
76179 }
76180
76181
76182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76183   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76184   Dali::Radian arg2 ;
76185   Dali::Radian *argp2 ;
76186
76187   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76188   argp2 = (Dali::Radian *)jarg2;
76189   if (!argp2) {
76190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76191     return ;
76192   }
76193   arg2 = *argp2;
76194   {
76195     try {
76196       (arg1)->RemoveScrollingDirection(arg2);
76197     } catch (std::out_of_range& e) {
76198       {
76199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76200       };
76201     } catch (std::exception& e) {
76202       {
76203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76204       };
76205     } catch (...) {
76206       {
76207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76208       };
76209     }
76210   }
76211 }
76212
76213
76214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76215   void * jresult ;
76216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76217   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76218
76219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76220   {
76221     try {
76222       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76223     } catch (std::out_of_range& e) {
76224       {
76225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76226       };
76227     } catch (std::exception& e) {
76228       {
76229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76230       };
76231     } catch (...) {
76232       {
76233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76234       };
76235     }
76236   }
76237   jresult = (void *)result;
76238   return jresult;
76239 }
76240
76241
76242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76243   int jresult ;
76244   int result;
76245
76246   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76247   jresult = (int)result;
76248   return jresult;
76249 }
76250
76251
76252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76253   int jresult ;
76254   int result;
76255
76256   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76257   jresult = (int)result;
76258   return jresult;
76259 }
76260
76261
76262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76263   int jresult ;
76264   int result;
76265
76266   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76267   jresult = (int)result;
76268   return jresult;
76269 }
76270
76271
76272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76273   int jresult ;
76274   int result;
76275
76276   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76277   jresult = (int)result;
76278   return jresult;
76279 }
76280
76281
76282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76283   int jresult ;
76284   int result;
76285
76286   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76287   jresult = (int)result;
76288   return jresult;
76289 }
76290
76291
76292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76293   void * jresult ;
76294   Dali::Toolkit::TableView::Property *result = 0 ;
76295
76296   {
76297     try {
76298       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76299     } catch (std::out_of_range& e) {
76300       {
76301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76302       };
76303     } catch (std::exception& e) {
76304       {
76305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76306       };
76307     } catch (...) {
76308       {
76309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76310       };
76311     }
76312   }
76313   jresult = (void *)result;
76314   return jresult;
76315 }
76316
76317
76318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76319   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76320
76321   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76322   {
76323     try {
76324       delete arg1;
76325     } catch (std::out_of_range& e) {
76326       {
76327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76328       };
76329     } catch (std::exception& e) {
76330       {
76331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76336       };
76337     }
76338   }
76339 }
76340
76341
76342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76343   int jresult ;
76344   int result;
76345
76346   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76347   jresult = (int)result;
76348   return jresult;
76349 }
76350
76351
76352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76353   int jresult ;
76354   int result;
76355
76356   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76357   jresult = (int)result;
76358   return jresult;
76359 }
76360
76361
76362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76363   int jresult ;
76364   int result;
76365
76366   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76367   jresult = (int)result;
76368   return jresult;
76369 }
76370
76371
76372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76373   int jresult ;
76374   int result;
76375
76376   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76377   jresult = (int)result;
76378   return jresult;
76379 }
76380
76381
76382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76383   int jresult ;
76384   int result;
76385
76386   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76387   jresult = (int)result;
76388   return jresult;
76389 }
76390
76391
76392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76393   void * jresult ;
76394   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76395
76396   {
76397     try {
76398       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (...) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76410       };
76411     }
76412   }
76413   jresult = (void *)result;
76414   return jresult;
76415 }
76416
76417
76418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76419   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76420
76421   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76422   {
76423     try {
76424       delete arg1;
76425     } catch (std::out_of_range& e) {
76426       {
76427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76428       };
76429     } catch (std::exception& e) {
76430       {
76431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76432       };
76433     } catch (...) {
76434       {
76435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76436       };
76437     }
76438   }
76439 }
76440
76441
76442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76443   void * jresult ;
76444   unsigned int arg1 ;
76445   unsigned int arg2 ;
76446   unsigned int arg3 ;
76447   unsigned int arg4 ;
76448   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76449
76450   arg1 = (unsigned int)jarg1;
76451   arg2 = (unsigned int)jarg2;
76452   arg3 = (unsigned int)jarg3;
76453   arg4 = (unsigned int)jarg4;
76454   {
76455     try {
76456       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76457     } catch (std::out_of_range& e) {
76458       {
76459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76460       };
76461     } catch (std::exception& e) {
76462       {
76463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76468       };
76469     }
76470   }
76471   jresult = (void *)result;
76472   return jresult;
76473 }
76474
76475
76476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76477   void * jresult ;
76478   unsigned int arg1 ;
76479   unsigned int arg2 ;
76480   unsigned int arg3 ;
76481   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76482
76483   arg1 = (unsigned int)jarg1;
76484   arg2 = (unsigned int)jarg2;
76485   arg3 = (unsigned int)jarg3;
76486   {
76487     try {
76488       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76489     } catch (std::out_of_range& e) {
76490       {
76491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76492       };
76493     } catch (std::exception& e) {
76494       {
76495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76496       };
76497     } catch (...) {
76498       {
76499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76500       };
76501     }
76502   }
76503   jresult = (void *)result;
76504   return jresult;
76505 }
76506
76507
76508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76509   void * jresult ;
76510   unsigned int arg1 ;
76511   unsigned int arg2 ;
76512   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76513
76514   arg1 = (unsigned int)jarg1;
76515   arg2 = (unsigned int)jarg2;
76516   {
76517     try {
76518       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76519     } catch (std::out_of_range& e) {
76520       {
76521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76522       };
76523     } catch (std::exception& e) {
76524       {
76525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76526       };
76527     } catch (...) {
76528       {
76529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76530       };
76531     }
76532   }
76533   jresult = (void *)result;
76534   return jresult;
76535 }
76536
76537
76538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76539   void * jresult ;
76540   unsigned int arg1 ;
76541   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76542
76543   arg1 = (unsigned int)jarg1;
76544   {
76545     try {
76546       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76547     } catch (std::out_of_range& e) {
76548       {
76549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (std::exception& e) {
76552       {
76553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76558       };
76559     }
76560   }
76561   jresult = (void *)result;
76562   return jresult;
76563 }
76564
76565
76566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76567   void * jresult ;
76568   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76569
76570   {
76571     try {
76572       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76573     } catch (std::out_of_range& e) {
76574       {
76575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76576       };
76577     } catch (std::exception& e) {
76578       {
76579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (...) {
76582       {
76583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76584       };
76585     }
76586   }
76587   jresult = (void *)result;
76588   return jresult;
76589 }
76590
76591
76592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex = arg2;
76599 }
76600
76601
76602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex);
76609   jresult = result;
76610   return jresult;
76611 }
76612
76613
76614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex = arg2;
76621 }
76622
76623
76624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex);
76631   jresult = result;
76632   return jresult;
76633 }
76634
76635
76636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan = arg2;
76643 }
76644
76645
76646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan);
76653   jresult = result;
76654   return jresult;
76655 }
76656
76657
76658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76659   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76660   unsigned int arg2 ;
76661
76662   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76663   arg2 = (unsigned int)jarg2;
76664   if (arg1) (arg1)->columnSpan = arg2;
76665 }
76666
76667
76668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76669   unsigned int jresult ;
76670   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76671   unsigned int result;
76672
76673   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76674   result = (unsigned int) ((arg1)->columnSpan);
76675   jresult = result;
76676   return jresult;
76677 }
76678
76679
76680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76681   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76682
76683   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76684   {
76685     try {
76686       delete arg1;
76687     } catch (std::out_of_range& e) {
76688       {
76689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76690       };
76691     } catch (std::exception& e) {
76692       {
76693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76694       };
76695     } catch (...) {
76696       {
76697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76698       };
76699     }
76700   }
76701 }
76702
76703
76704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76705   void * jresult ;
76706   Dali::Toolkit::TableView *result = 0 ;
76707
76708   {
76709     try {
76710       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76711     } catch (std::out_of_range& e) {
76712       {
76713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76714       };
76715     } catch (std::exception& e) {
76716       {
76717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76718       };
76719     } catch (...) {
76720       {
76721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76722       };
76723     }
76724   }
76725   jresult = (void *)result;
76726   return jresult;
76727 }
76728
76729
76730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76731   void * jresult ;
76732   Dali::Toolkit::TableView *arg1 = 0 ;
76733   Dali::Toolkit::TableView *result = 0 ;
76734
76735   arg1 = (Dali::Toolkit::TableView *)jarg1;
76736   if (!arg1) {
76737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76738     return 0;
76739   }
76740   {
76741     try {
76742       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76743     } catch (std::out_of_range& e) {
76744       {
76745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76746       };
76747     } catch (std::exception& e) {
76748       {
76749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (...) {
76752       {
76753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76754       };
76755     }
76756   }
76757   jresult = (void *)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76763   void * jresult ;
76764   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76765   Dali::Toolkit::TableView *arg2 = 0 ;
76766   Dali::Toolkit::TableView *result = 0 ;
76767
76768   arg1 = (Dali::Toolkit::TableView *)jarg1;
76769   arg2 = (Dali::Toolkit::TableView *)jarg2;
76770   if (!arg2) {
76771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76772     return 0;
76773   }
76774   {
76775     try {
76776       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76777     } catch (std::out_of_range& e) {
76778       {
76779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76780       };
76781     } catch (std::exception& e) {
76782       {
76783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76784       };
76785     } catch (...) {
76786       {
76787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76788       };
76789     }
76790   }
76791   jresult = (void *)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76797   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76798
76799   arg1 = (Dali::Toolkit::TableView *)jarg1;
76800   {
76801     try {
76802       delete arg1;
76803     } catch (std::out_of_range& e) {
76804       {
76805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76806       };
76807     } catch (std::exception& e) {
76808       {
76809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76810       };
76811     } catch (...) {
76812       {
76813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76814       };
76815     }
76816   }
76817 }
76818
76819
76820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76821   void * jresult ;
76822   unsigned int arg1 ;
76823   unsigned int arg2 ;
76824   Dali::Toolkit::TableView result;
76825
76826   arg1 = (unsigned int)jarg1;
76827   arg2 = (unsigned int)jarg2;
76828   {
76829     try {
76830       result = Dali::Toolkit::TableView::New(arg1,arg2);
76831     } catch (std::out_of_range& e) {
76832       {
76833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76834       };
76835     } catch (std::exception& e) {
76836       {
76837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76838       };
76839     } catch (...) {
76840       {
76841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76842       };
76843     }
76844   }
76845   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76846   return jresult;
76847 }
76848
76849
76850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76851   void * jresult ;
76852   Dali::BaseHandle arg1 ;
76853   Dali::BaseHandle *argp1 ;
76854   Dali::Toolkit::TableView result;
76855
76856   argp1 = (Dali::BaseHandle *)jarg1;
76857   if (!argp1) {
76858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76859     return 0;
76860   }
76861   arg1 = *argp1;
76862   {
76863     try {
76864       result = Dali::Toolkit::TableView::DownCast(arg1);
76865     } catch (std::out_of_range& e) {
76866       {
76867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76868       };
76869     } catch (std::exception& e) {
76870       {
76871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76872       };
76873     } catch (...) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76876       };
76877     }
76878   }
76879   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76880   return jresult;
76881 }
76882
76883
76884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76885   unsigned int jresult ;
76886   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76887   Dali::Actor arg2 ;
76888   Dali::Toolkit::TableView::CellPosition arg3 ;
76889   Dali::Actor *argp2 ;
76890   Dali::Toolkit::TableView::CellPosition *argp3 ;
76891   bool result;
76892
76893   arg1 = (Dali::Toolkit::TableView *)jarg1;
76894   argp2 = (Dali::Actor *)jarg2;
76895   if (!argp2) {
76896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76897     return 0;
76898   }
76899   arg2 = *argp2;
76900   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76901   if (!argp3) {
76902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76903     return 0;
76904   }
76905   arg3 = *argp3;
76906   {
76907     try {
76908       result = (bool)(arg1)->AddChild(arg2,arg3);
76909     } catch (std::out_of_range& e) {
76910       {
76911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76912       };
76913     } catch (std::exception& e) {
76914       {
76915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76916       };
76917     } catch (...) {
76918       {
76919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76920       };
76921     }
76922   }
76923   jresult = result;
76924   return jresult;
76925 }
76926
76927
76928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76929   void * jresult ;
76930   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76931   Dali::Toolkit::TableView::CellPosition arg2 ;
76932   Dali::Toolkit::TableView::CellPosition *argp2 ;
76933   Dali::Actor result;
76934
76935   arg1 = (Dali::Toolkit::TableView *)jarg1;
76936   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76937   if (!argp2) {
76938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76939     return 0;
76940   }
76941   arg2 = *argp2;
76942   {
76943     try {
76944       result = (arg1)->GetChildAt(arg2);
76945     } catch (std::out_of_range& e) {
76946       {
76947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76948       };
76949     } catch (std::exception& e) {
76950       {
76951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76952       };
76953     } catch (...) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76956       };
76957     }
76958   }
76959   jresult = new Dali::Actor((const Dali::Actor &)result);
76960   return jresult;
76961 }
76962
76963
76964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76965   void * jresult ;
76966   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76967   Dali::Toolkit::TableView::CellPosition arg2 ;
76968   Dali::Toolkit::TableView::CellPosition *argp2 ;
76969   Dali::Actor result;
76970
76971   arg1 = (Dali::Toolkit::TableView *)jarg1;
76972   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76973   if (!argp2) {
76974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76975     return 0;
76976   }
76977   arg2 = *argp2;
76978   {
76979     try {
76980       result = (arg1)->RemoveChildAt(arg2);
76981     } catch (std::out_of_range& e) {
76982       {
76983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76984       };
76985     } catch (std::exception& e) {
76986       {
76987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76988       };
76989     } catch (...) {
76990       {
76991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76992       };
76993     }
76994   }
76995   jresult = new Dali::Actor((const Dali::Actor &)result);
76996   return jresult;
76997 }
76998
76999
77000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77001   unsigned int jresult ;
77002   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77003   Dali::Actor arg2 ;
77004   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77005   Dali::Actor *argp2 ;
77006   bool result;
77007
77008   arg1 = (Dali::Toolkit::TableView *)jarg1;
77009   argp2 = (Dali::Actor *)jarg2;
77010   if (!argp2) {
77011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77012     return 0;
77013   }
77014   arg2 = *argp2;
77015   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77016   if (!arg3) {
77017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77018     return 0;
77019   }
77020   {
77021     try {
77022       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77023     } catch (std::out_of_range& e) {
77024       {
77025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77026       };
77027     } catch (std::exception& e) {
77028       {
77029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77030       };
77031     } catch (...) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77034       };
77035     }
77036   }
77037   jresult = result;
77038   return jresult;
77039 }
77040
77041
77042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77043   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77044   unsigned int arg2 ;
77045
77046   arg1 = (Dali::Toolkit::TableView *)jarg1;
77047   arg2 = (unsigned int)jarg2;
77048   {
77049     try {
77050       (arg1)->InsertRow(arg2);
77051     } catch (std::out_of_range& e) {
77052       {
77053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77054       };
77055     } catch (std::exception& e) {
77056       {
77057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77058       };
77059     } catch (...) {
77060       {
77061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77062       };
77063     }
77064   }
77065 }
77066
77067
77068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77069   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77070   unsigned int arg2 ;
77071
77072   arg1 = (Dali::Toolkit::TableView *)jarg1;
77073   arg2 = (unsigned int)jarg2;
77074   {
77075     try {
77076       (arg1)->DeleteRow(arg2);
77077     } catch (std::out_of_range& e) {
77078       {
77079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77080       };
77081     } catch (std::exception& e) {
77082       {
77083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77084       };
77085     } catch (...) {
77086       {
77087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77088       };
77089     }
77090   }
77091 }
77092
77093
77094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77095   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77096   unsigned int arg2 ;
77097   std::vector< Dali::Actor > *arg3 = 0 ;
77098
77099   arg1 = (Dali::Toolkit::TableView *)jarg1;
77100   arg2 = (unsigned int)jarg2;
77101   arg3 = (std::vector< Dali::Actor > *)jarg3;
77102   if (!arg3) {
77103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77104     return ;
77105   }
77106   {
77107     try {
77108       (arg1)->DeleteRow(arg2,*arg3);
77109     } catch (std::out_of_range& e) {
77110       {
77111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77112       };
77113     } catch (std::exception& e) {
77114       {
77115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77116       };
77117     } catch (...) {
77118       {
77119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77120       };
77121     }
77122   }
77123 }
77124
77125
77126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77127   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77128   unsigned int arg2 ;
77129
77130   arg1 = (Dali::Toolkit::TableView *)jarg1;
77131   arg2 = (unsigned int)jarg2;
77132   {
77133     try {
77134       (arg1)->InsertColumn(arg2);
77135     } catch (std::out_of_range& e) {
77136       {
77137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77138       };
77139     } catch (std::exception& e) {
77140       {
77141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77142       };
77143     } catch (...) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77146       };
77147     }
77148   }
77149 }
77150
77151
77152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77154   unsigned int arg2 ;
77155
77156   arg1 = (Dali::Toolkit::TableView *)jarg1;
77157   arg2 = (unsigned int)jarg2;
77158   {
77159     try {
77160       (arg1)->DeleteColumn(arg2);
77161     } catch (std::out_of_range& e) {
77162       {
77163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77164       };
77165     } catch (std::exception& e) {
77166       {
77167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77168       };
77169     } catch (...) {
77170       {
77171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77172       };
77173     }
77174   }
77175 }
77176
77177
77178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77179   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77180   unsigned int arg2 ;
77181   std::vector< Dali::Actor > *arg3 = 0 ;
77182
77183   arg1 = (Dali::Toolkit::TableView *)jarg1;
77184   arg2 = (unsigned int)jarg2;
77185   arg3 = (std::vector< Dali::Actor > *)jarg3;
77186   if (!arg3) {
77187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77188     return ;
77189   }
77190   {
77191     try {
77192       (arg1)->DeleteColumn(arg2,*arg3);
77193     } catch (std::out_of_range& e) {
77194       {
77195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (std::exception& e) {
77198       {
77199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77200       };
77201     } catch (...) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77204       };
77205     }
77206   }
77207 }
77208
77209
77210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77211   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77212   unsigned int arg2 ;
77213   unsigned int arg3 ;
77214
77215   arg1 = (Dali::Toolkit::TableView *)jarg1;
77216   arg2 = (unsigned int)jarg2;
77217   arg3 = (unsigned int)jarg3;
77218   {
77219     try {
77220       (arg1)->Resize(arg2,arg3);
77221     } catch (std::out_of_range& e) {
77222       {
77223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77224       };
77225     } catch (std::exception& e) {
77226       {
77227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77228       };
77229     } catch (...) {
77230       {
77231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77232       };
77233     }
77234   }
77235 }
77236
77237
77238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77239   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77240   unsigned int arg2 ;
77241   unsigned int arg3 ;
77242   std::vector< Dali::Actor > *arg4 = 0 ;
77243
77244   arg1 = (Dali::Toolkit::TableView *)jarg1;
77245   arg2 = (unsigned int)jarg2;
77246   arg3 = (unsigned int)jarg3;
77247   arg4 = (std::vector< Dali::Actor > *)jarg4;
77248   if (!arg4) {
77249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77250     return ;
77251   }
77252   {
77253     try {
77254       (arg1)->Resize(arg2,arg3,*arg4);
77255     } catch (std::out_of_range& e) {
77256       {
77257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77258       };
77259     } catch (std::exception& e) {
77260       {
77261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77262       };
77263     } catch (...) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77266       };
77267     }
77268   }
77269 }
77270
77271
77272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77273   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77274   Dali::Size arg2 ;
77275   Dali::Size *argp2 ;
77276
77277   arg1 = (Dali::Toolkit::TableView *)jarg1;
77278   argp2 = (Dali::Size *)jarg2;
77279   if (!argp2) {
77280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77281     return ;
77282   }
77283   arg2 = *argp2;
77284   {
77285     try {
77286       (arg1)->SetCellPadding(arg2);
77287     } catch (std::out_of_range& e) {
77288       {
77289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77290       };
77291     } catch (std::exception& e) {
77292       {
77293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77294       };
77295     } catch (...) {
77296       {
77297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77298       };
77299     }
77300   }
77301 }
77302
77303
77304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77305   void * jresult ;
77306   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77307   Dali::Size result;
77308
77309   arg1 = (Dali::Toolkit::TableView *)jarg1;
77310   {
77311     try {
77312       result = (arg1)->GetCellPadding();
77313     } catch (std::out_of_range& e) {
77314       {
77315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77316       };
77317     } catch (std::exception& e) {
77318       {
77319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77320       };
77321     } catch (...) {
77322       {
77323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77324       };
77325     }
77326   }
77327   jresult = new Dali::Size((const Dali::Size &)result);
77328   return jresult;
77329 }
77330
77331
77332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77334   unsigned int arg2 ;
77335
77336   arg1 = (Dali::Toolkit::TableView *)jarg1;
77337   arg2 = (unsigned int)jarg2;
77338   {
77339     try {
77340       (arg1)->SetFitHeight(arg2);
77341     } catch (std::out_of_range& e) {
77342       {
77343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77344       };
77345     } catch (std::exception& e) {
77346       {
77347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77348       };
77349     } catch (...) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77352       };
77353     }
77354   }
77355 }
77356
77357
77358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77359   unsigned int jresult ;
77360   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77361   unsigned int arg2 ;
77362   bool result;
77363
77364   arg1 = (Dali::Toolkit::TableView *)jarg1;
77365   arg2 = (unsigned int)jarg2;
77366   {
77367     try {
77368       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77369     } catch (std::out_of_range& e) {
77370       {
77371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77372       };
77373     } catch (std::exception& e) {
77374       {
77375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77376       };
77377     } catch (...) {
77378       {
77379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77380       };
77381     }
77382   }
77383   jresult = result;
77384   return jresult;
77385 }
77386
77387
77388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77389   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77390   unsigned int arg2 ;
77391
77392   arg1 = (Dali::Toolkit::TableView *)jarg1;
77393   arg2 = (unsigned int)jarg2;
77394   {
77395     try {
77396       (arg1)->SetFitWidth(arg2);
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77404       };
77405     } catch (...) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77408       };
77409     }
77410   }
77411 }
77412
77413
77414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77415   unsigned int jresult ;
77416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77417   unsigned int arg2 ;
77418   bool result;
77419
77420   arg1 = (Dali::Toolkit::TableView *)jarg1;
77421   arg2 = (unsigned int)jarg2;
77422   {
77423     try {
77424       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77436       };
77437     }
77438   }
77439   jresult = result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77445   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77446   unsigned int arg2 ;
77447   float arg3 ;
77448
77449   arg1 = (Dali::Toolkit::TableView *)jarg1;
77450   arg2 = (unsigned int)jarg2;
77451   arg3 = (float)jarg3;
77452   {
77453     try {
77454       (arg1)->SetFixedHeight(arg2,arg3);
77455     } catch (std::out_of_range& e) {
77456       {
77457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77458       };
77459     } catch (std::exception& e) {
77460       {
77461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77462       };
77463     } catch (...) {
77464       {
77465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77466       };
77467     }
77468   }
77469 }
77470
77471
77472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77473   float jresult ;
77474   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77475   unsigned int arg2 ;
77476   float result;
77477
77478   arg1 = (Dali::Toolkit::TableView *)jarg1;
77479   arg2 = (unsigned int)jarg2;
77480   {
77481     try {
77482       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77483     } catch (std::out_of_range& e) {
77484       {
77485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77486       };
77487     } catch (std::exception& e) {
77488       {
77489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (...) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77494       };
77495     }
77496   }
77497   jresult = result;
77498   return jresult;
77499 }
77500
77501
77502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77503   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77504   unsigned int arg2 ;
77505   float arg3 ;
77506
77507   arg1 = (Dali::Toolkit::TableView *)jarg1;
77508   arg2 = (unsigned int)jarg2;
77509   arg3 = (float)jarg3;
77510   {
77511     try {
77512       (arg1)->SetRelativeHeight(arg2,arg3);
77513     } catch (std::out_of_range& e) {
77514       {
77515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77516       };
77517     } catch (std::exception& e) {
77518       {
77519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77520       };
77521     } catch (...) {
77522       {
77523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77524       };
77525     }
77526   }
77527 }
77528
77529
77530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77531   float jresult ;
77532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77533   unsigned int arg2 ;
77534   float result;
77535
77536   arg1 = (Dali::Toolkit::TableView *)jarg1;
77537   arg2 = (unsigned int)jarg2;
77538   {
77539     try {
77540       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77541     } catch (std::out_of_range& e) {
77542       {
77543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77544       };
77545     } catch (std::exception& e) {
77546       {
77547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77548       };
77549     } catch (...) {
77550       {
77551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77552       };
77553     }
77554   }
77555   jresult = result;
77556   return jresult;
77557 }
77558
77559
77560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77562   unsigned int arg2 ;
77563   float arg3 ;
77564
77565   arg1 = (Dali::Toolkit::TableView *)jarg1;
77566   arg2 = (unsigned int)jarg2;
77567   arg3 = (float)jarg3;
77568   {
77569     try {
77570       (arg1)->SetFixedWidth(arg2,arg3);
77571     } catch (std::out_of_range& e) {
77572       {
77573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77574       };
77575     } catch (std::exception& e) {
77576       {
77577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77578       };
77579     } catch (...) {
77580       {
77581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77582       };
77583     }
77584   }
77585 }
77586
77587
77588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77589   float jresult ;
77590   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77591   unsigned int arg2 ;
77592   float result;
77593
77594   arg1 = (Dali::Toolkit::TableView *)jarg1;
77595   arg2 = (unsigned int)jarg2;
77596   {
77597     try {
77598       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77599     } catch (std::out_of_range& e) {
77600       {
77601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77602       };
77603     } catch (std::exception& e) {
77604       {
77605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77606       };
77607     } catch (...) {
77608       {
77609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77610       };
77611     }
77612   }
77613   jresult = result;
77614   return jresult;
77615 }
77616
77617
77618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77620   unsigned int arg2 ;
77621   float arg3 ;
77622
77623   arg1 = (Dali::Toolkit::TableView *)jarg1;
77624   arg2 = (unsigned int)jarg2;
77625   arg3 = (float)jarg3;
77626   {
77627     try {
77628       (arg1)->SetRelativeWidth(arg2,arg3);
77629     } catch (std::out_of_range& e) {
77630       {
77631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77632       };
77633     } catch (std::exception& e) {
77634       {
77635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77636       };
77637     } catch (...) {
77638       {
77639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77640       };
77641     }
77642   }
77643 }
77644
77645
77646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77647   float jresult ;
77648   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77649   unsigned int arg2 ;
77650   float result;
77651
77652   arg1 = (Dali::Toolkit::TableView *)jarg1;
77653   arg2 = (unsigned int)jarg2;
77654   {
77655     try {
77656       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77657     } catch (std::out_of_range& e) {
77658       {
77659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77660       };
77661     } catch (std::exception& e) {
77662       {
77663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77664       };
77665     } catch (...) {
77666       {
77667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77668       };
77669     }
77670   }
77671   jresult = result;
77672   return jresult;
77673 }
77674
77675
77676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77677   unsigned int jresult ;
77678   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77679   unsigned int result;
77680
77681   arg1 = (Dali::Toolkit::TableView *)jarg1;
77682   {
77683     try {
77684       result = (unsigned int)(arg1)->GetRows();
77685     } catch (std::out_of_range& e) {
77686       {
77687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77688       };
77689     } catch (std::exception& e) {
77690       {
77691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77696       };
77697     }
77698   }
77699   jresult = result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77705   unsigned int jresult ;
77706   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77707   unsigned int result;
77708
77709   arg1 = (Dali::Toolkit::TableView *)jarg1;
77710   {
77711     try {
77712       result = (unsigned int)(arg1)->GetColumns();
77713     } catch (std::out_of_range& e) {
77714       {
77715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77716       };
77717     } catch (std::exception& e) {
77718       {
77719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77724       };
77725     }
77726   }
77727   jresult = result;
77728   return jresult;
77729 }
77730
77731
77732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77733   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77734   Dali::Toolkit::TableView::CellPosition arg2 ;
77735   Dali::HorizontalAlignment::Type arg3 ;
77736   Dali::VerticalAlignment::Type arg4 ;
77737   Dali::Toolkit::TableView::CellPosition *argp2 ;
77738
77739   arg1 = (Dali::Toolkit::TableView *)jarg1;
77740   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77741   if (!argp2) {
77742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77743     return ;
77744   }
77745   arg2 = *argp2;
77746   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77747   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77748   {
77749     try {
77750       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77751     } catch (std::out_of_range& e) {
77752       {
77753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77754       };
77755     } catch (std::exception& e) {
77756       {
77757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77758       };
77759     } catch (...) {
77760       {
77761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77762       };
77763     }
77764   }
77765 }
77766
77767
77768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77769   unsigned int jresult ;
77770   unsigned int result;
77771
77772   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77773   jresult = result;
77774   return jresult;
77775 }
77776
77777
77778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77779   int jresult ;
77780   int result;
77781
77782   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77783   jresult = (int)result;
77784   return jresult;
77785 }
77786
77787
77788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77789   int jresult ;
77790   int result;
77791
77792   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77793   jresult = (int)result;
77794   return jresult;
77795 }
77796
77797
77798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77799   int jresult ;
77800   int result;
77801
77802   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77803   jresult = (int)result;
77804   return jresult;
77805 }
77806
77807
77808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77809   int jresult ;
77810   int result;
77811
77812   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77813   jresult = (int)result;
77814   return jresult;
77815 }
77816
77817
77818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77819   int jresult ;
77820   int result;
77821
77822   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77823   jresult = (int)result;
77824   return jresult;
77825 }
77826
77827
77828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77829   int jresult ;
77830   int result;
77831
77832   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77833   jresult = (int)result;
77834   return jresult;
77835 }
77836
77837
77838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77839   int jresult ;
77840   int result;
77841
77842   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77843   jresult = (int)result;
77844   return jresult;
77845 }
77846
77847
77848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77849   int jresult ;
77850   int result;
77851
77852   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77853   jresult = (int)result;
77854   return jresult;
77855 }
77856
77857
77858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77859   int jresult ;
77860   int result;
77861
77862   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77863   jresult = (int)result;
77864   return jresult;
77865 }
77866
77867
77868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77869   int jresult ;
77870   int result;
77871
77872   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77873   jresult = (int)result;
77874   return jresult;
77875 }
77876
77877
77878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77879   int jresult ;
77880   int result;
77881
77882   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77883   jresult = (int)result;
77884   return jresult;
77885 }
77886
77887
77888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77889   int jresult ;
77890   int result;
77891
77892   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77893   jresult = (int)result;
77894   return jresult;
77895 }
77896
77897
77898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77899   int jresult ;
77900   int result;
77901
77902   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77903   jresult = (int)result;
77904   return jresult;
77905 }
77906
77907
77908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77909   int jresult ;
77910   int result;
77911
77912   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77913   jresult = (int)result;
77914   return jresult;
77915 }
77916
77917
77918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77919   int jresult ;
77920   int result;
77921
77922   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77923   jresult = (int)result;
77924   return jresult;
77925 }
77926
77927
77928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77929   int jresult ;
77930   int result;
77931
77932   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77933   jresult = (int)result;
77934   return jresult;
77935 }
77936
77937
77938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77939   int jresult ;
77940   int result;
77941
77942   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77943   jresult = (int)result;
77944   return jresult;
77945 }
77946
77947
77948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77949   int jresult ;
77950   int result;
77951
77952   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77953   jresult = (int)result;
77954   return jresult;
77955 }
77956
77957
77958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77959   int jresult ;
77960   int result;
77961
77962   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77963   jresult = (int)result;
77964   return jresult;
77965 }
77966
77967
77968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77969   int jresult ;
77970   int result;
77971
77972   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77973   jresult = (int)result;
77974   return jresult;
77975 }
77976
77977
77978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77979   int jresult ;
77980   int result;
77981
77982   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77983   jresult = (int)result;
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77989   int jresult ;
77990   int result;
77991
77992   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77993   jresult = (int)result;
77994   return jresult;
77995 }
77996
77997
77998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77999   int jresult ;
78000   int result;
78001
78002   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78003   jresult = (int)result;
78004   return jresult;
78005 }
78006
78007
78008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78009   int jresult ;
78010   int result;
78011
78012   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
78013   jresult = (int)result;
78014   return jresult;
78015 }
78016
78017
78018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
78019   int jresult ;
78020   int result;
78021
78022   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
78023   jresult = (int)result;
78024   return jresult;
78025 }
78026
78027
78028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
78029   int jresult ;
78030   int result;
78031
78032   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
78033   jresult = (int)result;
78034   return jresult;
78035 }
78036
78037
78038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
78039   int jresult ;
78040   int result;
78041
78042   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
78043   jresult = (int)result;
78044   return jresult;
78045 }
78046
78047
78048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
78049   int jresult ;
78050   int result;
78051
78052   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
78053   jresult = (int)result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
78059   int jresult ;
78060   int result;
78061
78062   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
78063   jresult = (int)result;
78064   return jresult;
78065 }
78066
78067
78068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
78069   int jresult ;
78070   int result;
78071
78072   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
78073   jresult = (int)result;
78074   return jresult;
78075 }
78076
78077
78078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
78079   int jresult ;
78080   int result;
78081
78082   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
78083   jresult = (int)result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
78089   int jresult ;
78090   int result;
78091
78092   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
78093   jresult = (int)result;
78094   return jresult;
78095 }
78096
78097
78098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
78099   int jresult ;
78100   int result;
78101
78102   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
78103   jresult = (int)result;
78104   return jresult;
78105 }
78106
78107
78108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
78109   int jresult ;
78110   int result;
78111
78112   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
78113   jresult = (int)result;
78114   return jresult;
78115 }
78116
78117
78118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
78119   int jresult ;
78120   int result;
78121
78122   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
78123   jresult = (int)result;
78124   return jresult;
78125 }
78126
78127
78128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
78129   int jresult ;
78130   int result;
78131
78132   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
78133   jresult = (int)result;
78134   return jresult;
78135 }
78136
78137
78138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78139   int jresult ;
78140   int result;
78141
78142   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78143   jresult = (int)result;
78144   return jresult;
78145 }
78146
78147
78148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78149   int jresult ;
78150   int result;
78151
78152   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78153   jresult = (int)result;
78154   return jresult;
78155 }
78156
78157
78158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78159   int jresult ;
78160   int result;
78161
78162   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78163   jresult = (int)result;
78164   return jresult;
78165 }
78166
78167
78168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78169   int jresult ;
78170   int result;
78171
78172   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78173   jresult = (int)result;
78174   return jresult;
78175 }
78176
78177
78178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78179   void * jresult ;
78180   Dali::Toolkit::TextEditor::Property *result = 0 ;
78181
78182   {
78183     try {
78184       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78185     } catch (std::out_of_range& e) {
78186       {
78187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78188       };
78189     } catch (std::exception& e) {
78190       {
78191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78192       };
78193     } catch (...) {
78194       {
78195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78196       };
78197     }
78198   }
78199   jresult = (void *)result;
78200   return jresult;
78201 }
78202
78203
78204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78205   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78206
78207   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78208   {
78209     try {
78210       delete arg1;
78211     } catch (std::out_of_range& e) {
78212       {
78213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78214       };
78215     } catch (std::exception& e) {
78216       {
78217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78218       };
78219     } catch (...) {
78220       {
78221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78222       };
78223     }
78224   }
78225 }
78226
78227
78228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78229   void * jresult ;
78230   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78231
78232   {
78233     try {
78234       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78235     } catch (std::out_of_range& e) {
78236       {
78237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78238       };
78239     } catch (std::exception& e) {
78240       {
78241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78242       };
78243     } catch (...) {
78244       {
78245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78246       };
78247     }
78248   }
78249   jresult = (void *)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78255   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78256
78257   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78258   {
78259     try {
78260       delete arg1;
78261     } catch (std::out_of_range& e) {
78262       {
78263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78264       };
78265     } catch (std::exception& e) {
78266       {
78267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78268       };
78269     } catch (...) {
78270       {
78271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78272       };
78273     }
78274   }
78275 }
78276
78277
78278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78279   void * jresult ;
78280   Dali::Toolkit::TextEditor result;
78281
78282   {
78283     try {
78284       result = Dali::Toolkit::TextEditor::New();
78285     } catch (std::out_of_range& e) {
78286       {
78287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78288       };
78289     } catch (std::exception& e) {
78290       {
78291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78292       };
78293     } catch (...) {
78294       {
78295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78296       };
78297     }
78298   }
78299   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78305   void * jresult ;
78306   Dali::Toolkit::TextEditor *result = 0 ;
78307
78308   {
78309     try {
78310       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78311     } catch (std::out_of_range& e) {
78312       {
78313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78314       };
78315     } catch (std::exception& e) {
78316       {
78317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78318       };
78319     } catch (...) {
78320       {
78321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78322       };
78323     }
78324   }
78325   jresult = (void *)result;
78326   return jresult;
78327 }
78328
78329
78330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78331   void * jresult ;
78332   Dali::Toolkit::TextEditor *arg1 = 0 ;
78333   Dali::Toolkit::TextEditor *result = 0 ;
78334
78335   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78336   if (!arg1) {
78337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78338     return 0;
78339   }
78340   {
78341     try {
78342       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78343     } catch (std::out_of_range& e) {
78344       {
78345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78346       };
78347     } catch (std::exception& e) {
78348       {
78349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78350       };
78351     } catch (...) {
78352       {
78353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78354       };
78355     }
78356   }
78357   jresult = (void *)result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78363   void * jresult ;
78364   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78365   Dali::Toolkit::TextEditor *arg2 = 0 ;
78366   Dali::Toolkit::TextEditor *result = 0 ;
78367
78368   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78369   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78370   if (!arg2) {
78371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78372     return 0;
78373   }
78374   {
78375     try {
78376       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78377     } catch (std::out_of_range& e) {
78378       {
78379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78380       };
78381     } catch (std::exception& e) {
78382       {
78383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78384       };
78385     } catch (...) {
78386       {
78387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78388       };
78389     }
78390   }
78391   jresult = (void *)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78397   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78398
78399   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78400   {
78401     try {
78402       delete arg1;
78403     } catch (std::out_of_range& e) {
78404       {
78405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78406       };
78407     } catch (std::exception& e) {
78408       {
78409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78410       };
78411     } catch (...) {
78412       {
78413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78414       };
78415     }
78416   }
78417 }
78418
78419
78420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78421   void * jresult ;
78422   Dali::BaseHandle arg1 ;
78423   Dali::BaseHandle *argp1 ;
78424   Dali::Toolkit::TextEditor result;
78425
78426   argp1 = (Dali::BaseHandle *)jarg1;
78427   if (!argp1) {
78428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78429     return 0;
78430   }
78431   arg1 = *argp1;
78432   {
78433     try {
78434       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78435     } catch (std::out_of_range& e) {
78436       {
78437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78438       };
78439     } catch (std::exception& e) {
78440       {
78441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78442       };
78443     } catch (...) {
78444       {
78445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78446       };
78447     }
78448   }
78449   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78455   void * jresult ;
78456   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78457   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78458
78459   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78460   {
78461     try {
78462       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78463     } catch (std::out_of_range& e) {
78464       {
78465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78466       };
78467     } catch (std::exception& e) {
78468       {
78469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78470       };
78471     } catch (...) {
78472       {
78473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78474       };
78475     }
78476   }
78477   jresult = (void *)result;
78478   return jresult;
78479 }
78480
78481
78482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78483   void * jresult ;
78484   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78485   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78486
78487   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78488   {
78489     try {
78490       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78491     } catch (std::out_of_range& e) {
78492       {
78493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78494       };
78495     } catch (std::exception& e) {
78496       {
78497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78498       };
78499     } catch (...) {
78500       {
78501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78502       };
78503     }
78504   }
78505   jresult = (void *)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78511   int jresult ;
78512   int result;
78513
78514   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78515   jresult = (int)result;
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78521   int jresult ;
78522   int result;
78523
78524   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78525   jresult = (int)result;
78526   return jresult;
78527 }
78528
78529
78530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78531   int jresult ;
78532   int result;
78533
78534   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78535   jresult = (int)result;
78536   return jresult;
78537 }
78538
78539
78540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78541   int jresult ;
78542   int result;
78543
78544   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78545   jresult = (int)result;
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78551   int jresult ;
78552   int result;
78553
78554   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78555   jresult = (int)result;
78556   return jresult;
78557 }
78558
78559
78560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78561   int jresult ;
78562   int result;
78563
78564   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78565   jresult = (int)result;
78566   return jresult;
78567 }
78568
78569
78570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78571   int jresult ;
78572   int result;
78573
78574   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78575   jresult = (int)result;
78576   return jresult;
78577 }
78578
78579
78580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78581   int jresult ;
78582   int result;
78583
78584   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78585   jresult = (int)result;
78586   return jresult;
78587 }
78588
78589
78590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78591   int jresult ;
78592   int result;
78593
78594   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78595   jresult = (int)result;
78596   return jresult;
78597 }
78598
78599
78600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78601   int jresult ;
78602   int result;
78603
78604   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78605   jresult = (int)result;
78606   return jresult;
78607 }
78608
78609
78610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78611   int jresult ;
78612   int result;
78613
78614   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78615   jresult = (int)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78621   int jresult ;
78622   int result;
78623
78624   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78625   jresult = (int)result;
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78631   int jresult ;
78632   int result;
78633
78634   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78635   jresult = (int)result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78641   int jresult ;
78642   int result;
78643
78644   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78645   jresult = (int)result;
78646   return jresult;
78647 }
78648
78649
78650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78651   int jresult ;
78652   int result;
78653
78654   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78655   jresult = (int)result;
78656   return jresult;
78657 }
78658
78659
78660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78661   int jresult ;
78662   int result;
78663
78664   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78665   jresult = (int)result;
78666   return jresult;
78667 }
78668
78669
78670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78671   int jresult ;
78672   int result;
78673
78674   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78675   jresult = (int)result;
78676   return jresult;
78677 }
78678
78679
78680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78681   int jresult ;
78682   int result;
78683
78684   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78685   jresult = (int)result;
78686   return jresult;
78687 }
78688
78689
78690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78691   int jresult ;
78692   int result;
78693
78694   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78695   jresult = (int)result;
78696   return jresult;
78697 }
78698
78699
78700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78701   int jresult ;
78702   int result;
78703
78704   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78705   jresult = (int)result;
78706   return jresult;
78707 }
78708
78709
78710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78711   int jresult ;
78712   int result;
78713
78714   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78715   jresult = (int)result;
78716   return jresult;
78717 }
78718
78719
78720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78721   int jresult ;
78722   int result;
78723
78724   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78725   jresult = (int)result;
78726   return jresult;
78727 }
78728
78729
78730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78731   int jresult ;
78732   int result;
78733
78734   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78735   jresult = (int)result;
78736   return jresult;
78737 }
78738
78739
78740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78741   int jresult ;
78742   int result;
78743
78744   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78745   jresult = (int)result;
78746   return jresult;
78747 }
78748
78749
78750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78751   int jresult ;
78752   int result;
78753
78754   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78755   jresult = (int)result;
78756   return jresult;
78757 }
78758
78759
78760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78761   int jresult ;
78762   int result;
78763
78764   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78765   jresult = (int)result;
78766   return jresult;
78767 }
78768
78769
78770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78771   int jresult ;
78772   int result;
78773
78774   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78775   jresult = (int)result;
78776   return jresult;
78777 }
78778
78779
78780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78781   int jresult ;
78782   int result;
78783
78784   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78785   jresult = (int)result;
78786   return jresult;
78787 }
78788
78789
78790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78791   int jresult ;
78792   int result;
78793
78794   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78795   jresult = (int)result;
78796   return jresult;
78797 }
78798
78799
78800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78801   int jresult ;
78802   int result;
78803
78804   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78805   jresult = (int)result;
78806   return jresult;
78807 }
78808
78809
78810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78811   int jresult ;
78812   int result;
78813
78814   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78815   jresult = (int)result;
78816   return jresult;
78817 }
78818
78819
78820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78821   int jresult ;
78822   int result;
78823
78824   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78825   jresult = (int)result;
78826   return jresult;
78827 }
78828
78829
78830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78831   int jresult ;
78832   int result;
78833
78834   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78835   jresult = (int)result;
78836   return jresult;
78837 }
78838
78839
78840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78841   int jresult ;
78842   int result;
78843
78844   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78845   jresult = (int)result;
78846   return jresult;
78847 }
78848
78849
78850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78851   int jresult ;
78852   int result;
78853
78854   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78855   jresult = (int)result;
78856   return jresult;
78857 }
78858
78859
78860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78861   int jresult ;
78862   int result;
78863
78864   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78865   jresult = (int)result;
78866   return jresult;
78867 }
78868
78869
78870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78871   int jresult ;
78872   int result;
78873
78874   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78875   jresult = (int)result;
78876   return jresult;
78877 }
78878
78879
78880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78881   int jresult ;
78882   int result;
78883
78884   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78885   jresult = (int)result;
78886   return jresult;
78887 }
78888
78889
78890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78891   int jresult ;
78892   int result;
78893
78894   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78895   jresult = (int)result;
78896   return jresult;
78897 }
78898
78899
78900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78901   int jresult ;
78902   int result;
78903
78904   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78905   jresult = (int)result;
78906   return jresult;
78907 }
78908
78909
78910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78911   int jresult ;
78912   int result;
78913
78914   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78915   jresult = (int)result;
78916   return jresult;
78917 }
78918
78919
78920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78921   int jresult ;
78922   int result;
78923
78924   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78925   jresult = (int)result;
78926   return jresult;
78927 }
78928
78929
78930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78931   int jresult ;
78932   int result;
78933
78934   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78935   jresult = (int)result;
78936   return jresult;
78937 }
78938
78939
78940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78941   int jresult ;
78942   int result;
78943
78944   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78945   jresult = (int)result;
78946   return jresult;
78947 }
78948
78949
78950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78951   int jresult ;
78952   int result;
78953
78954   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78955   jresult = (int)result;
78956   return jresult;
78957 }
78958
78959
78960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78961   int jresult ;
78962   int result;
78963
78964   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78965   jresult = (int)result;
78966   return jresult;
78967 }
78968
78969
78970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78971   int jresult ;
78972   int result;
78973
78974   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78975   jresult = (int)result;
78976   return jresult;
78977 }
78978
78979
78980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78981   void * jresult ;
78982   Dali::Toolkit::TextField::Property *result = 0 ;
78983
78984   {
78985     try {
78986       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78987     } catch (std::out_of_range& e) {
78988       {
78989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78990       };
78991     } catch (std::exception& e) {
78992       {
78993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78994       };
78995     } catch (...) {
78996       {
78997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78998       };
78999     }
79000   }
79001   jresult = (void *)result;
79002   return jresult;
79003 }
79004
79005
79006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
79007   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
79008
79009   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
79010   {
79011     try {
79012       delete arg1;
79013     } catch (std::out_of_range& e) {
79014       {
79015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79016       };
79017     } catch (std::exception& e) {
79018       {
79019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79020       };
79021     } catch (...) {
79022       {
79023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79024       };
79025     }
79026   }
79027 }
79028
79029
79030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
79031   void * jresult ;
79032   Dali::Toolkit::TextField::InputStyle *result = 0 ;
79033
79034   {
79035     try {
79036       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
79037     } catch (std::out_of_range& e) {
79038       {
79039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79040       };
79041     } catch (std::exception& e) {
79042       {
79043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (...) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79048       };
79049     }
79050   }
79051   jresult = (void *)result;
79052   return jresult;
79053 }
79054
79055
79056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
79057   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
79058
79059   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
79060   {
79061     try {
79062       delete arg1;
79063     } catch (std::out_of_range& e) {
79064       {
79065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79066       };
79067     } catch (std::exception& e) {
79068       {
79069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79070       };
79071     } catch (...) {
79072       {
79073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79074       };
79075     }
79076   }
79077 }
79078
79079
79080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
79081   void * jresult ;
79082   Dali::Toolkit::TextField result;
79083
79084   {
79085     try {
79086       result = Dali::Toolkit::TextField::New();
79087     } catch (std::out_of_range& e) {
79088       {
79089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79090       };
79091     } catch (std::exception& e) {
79092       {
79093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (...) {
79096       {
79097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79098       };
79099     }
79100   }
79101   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79102   return jresult;
79103 }
79104
79105
79106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
79107   void * jresult ;
79108   Dali::Toolkit::TextField *result = 0 ;
79109
79110   {
79111     try {
79112       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
79113     } catch (std::out_of_range& e) {
79114       {
79115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79116       };
79117     } catch (std::exception& e) {
79118       {
79119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79120       };
79121     } catch (...) {
79122       {
79123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79124       };
79125     }
79126   }
79127   jresult = (void *)result;
79128   return jresult;
79129 }
79130
79131
79132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
79133   void * jresult ;
79134   Dali::Toolkit::TextField *arg1 = 0 ;
79135   Dali::Toolkit::TextField *result = 0 ;
79136
79137   arg1 = (Dali::Toolkit::TextField *)jarg1;
79138   if (!arg1) {
79139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79140     return 0;
79141   }
79142   {
79143     try {
79144       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79145     } catch (std::out_of_range& e) {
79146       {
79147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79148       };
79149     } catch (std::exception& e) {
79150       {
79151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79152       };
79153     } catch (...) {
79154       {
79155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79156       };
79157     }
79158   }
79159   jresult = (void *)result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79165   void * jresult ;
79166   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79167   Dali::Toolkit::TextField *arg2 = 0 ;
79168   Dali::Toolkit::TextField *result = 0 ;
79169
79170   arg1 = (Dali::Toolkit::TextField *)jarg1;
79171   arg2 = (Dali::Toolkit::TextField *)jarg2;
79172   if (!arg2) {
79173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79174     return 0;
79175   }
79176   {
79177     try {
79178       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79179     } catch (std::out_of_range& e) {
79180       {
79181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79182       };
79183     } catch (std::exception& e) {
79184       {
79185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79190       };
79191     }
79192   }
79193   jresult = (void *)result;
79194   return jresult;
79195 }
79196
79197
79198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79199   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79200
79201   arg1 = (Dali::Toolkit::TextField *)jarg1;
79202   {
79203     try {
79204       delete arg1;
79205     } catch (std::out_of_range& e) {
79206       {
79207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79208       };
79209     } catch (std::exception& e) {
79210       {
79211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79212       };
79213     } catch (...) {
79214       {
79215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79216       };
79217     }
79218   }
79219 }
79220
79221
79222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79223   void * jresult ;
79224   Dali::BaseHandle arg1 ;
79225   Dali::BaseHandle *argp1 ;
79226   Dali::Toolkit::TextField result;
79227
79228   argp1 = (Dali::BaseHandle *)jarg1;
79229   if (!argp1) {
79230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79231     return 0;
79232   }
79233   arg1 = *argp1;
79234   {
79235     try {
79236       result = Dali::Toolkit::TextField::DownCast(arg1);
79237     } catch (std::out_of_range& e) {
79238       {
79239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (std::exception& e) {
79242       {
79243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79252   return jresult;
79253 }
79254
79255
79256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79257   void * jresult ;
79258   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79259   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79260
79261   arg1 = (Dali::Toolkit::TextField *)jarg1;
79262   {
79263     try {
79264       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79265     } catch (std::out_of_range& e) {
79266       {
79267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79268       };
79269     } catch (std::exception& e) {
79270       {
79271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79272       };
79273     } catch (...) {
79274       {
79275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79276       };
79277     }
79278   }
79279   jresult = (void *)result;
79280   return jresult;
79281 }
79282
79283
79284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79285   void * jresult ;
79286   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79287   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79288
79289   arg1 = (Dali::Toolkit::TextField *)jarg1;
79290   {
79291     try {
79292       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79293     } catch (std::out_of_range& e) {
79294       {
79295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79296       };
79297     } catch (std::exception& e) {
79298       {
79299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79300       };
79301     } catch (...) {
79302       {
79303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79304       };
79305     }
79306   }
79307   jresult = (void *)result;
79308   return jresult;
79309 }
79310
79311
79312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79313   void * jresult ;
79314   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79315   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79316
79317   arg1 = (Dali::Toolkit::TextField *)jarg1;
79318   {
79319     try {
79320       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79321     } catch (std::out_of_range& e) {
79322       {
79323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79324       };
79325     } catch (std::exception& e) {
79326       {
79327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (...) {
79330       {
79331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79332       };
79333     }
79334   }
79335   jresult = (void *)result;
79336   return jresult;
79337 }
79338
79339
79340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79341   int jresult ;
79342   int result;
79343
79344   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79345   jresult = (int)result;
79346   return jresult;
79347 }
79348
79349
79350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79351   int jresult ;
79352   int result;
79353
79354   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79355   jresult = (int)result;
79356   return jresult;
79357 }
79358
79359
79360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79361   int jresult ;
79362   int result;
79363
79364   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79365   jresult = (int)result;
79366   return jresult;
79367 }
79368
79369
79370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79371   int jresult ;
79372   int result;
79373
79374   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79375   jresult = (int)result;
79376   return jresult;
79377 }
79378
79379
79380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79381   int jresult ;
79382   int result;
79383
79384   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79385   jresult = (int)result;
79386   return jresult;
79387 }
79388
79389
79390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79391   int jresult ;
79392   int result;
79393
79394   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79395   jresult = (int)result;
79396   return jresult;
79397 }
79398
79399
79400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79401   int jresult ;
79402   int result;
79403
79404   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79405   jresult = (int)result;
79406   return jresult;
79407 }
79408
79409
79410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79411   int jresult ;
79412   int result;
79413
79414   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79415   jresult = (int)result;
79416   return jresult;
79417 }
79418
79419
79420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79421   int jresult ;
79422   int result;
79423
79424   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79425   jresult = (int)result;
79426   return jresult;
79427 }
79428
79429
79430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79431   int jresult ;
79432   int result;
79433
79434   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79435   jresult = (int)result;
79436   return jresult;
79437 }
79438
79439
79440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79441   int jresult ;
79442   int result;
79443
79444   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79445   jresult = (int)result;
79446   return jresult;
79447 }
79448
79449
79450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79451   int jresult ;
79452   int result;
79453
79454   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79455   jresult = (int)result;
79456   return jresult;
79457 }
79458
79459
79460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79461   int jresult ;
79462   int result;
79463
79464   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79465   jresult = (int)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79471   int jresult ;
79472   int result;
79473
79474   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79475   jresult = (int)result;
79476   return jresult;
79477 }
79478
79479
79480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79481   int jresult ;
79482   int result;
79483
79484   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79485   jresult = (int)result;
79486   return jresult;
79487 }
79488
79489
79490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79491   int jresult ;
79492   int result;
79493
79494   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79495   jresult = (int)result;
79496   return jresult;
79497 }
79498
79499
79500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79501   int jresult ;
79502   int result;
79503
79504   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79505   jresult = (int)result;
79506   return jresult;
79507 }
79508
79509
79510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79511   int jresult ;
79512   int result;
79513
79514   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79515   jresult = (int)result;
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79521   int jresult ;
79522   int result;
79523
79524   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79525   jresult = (int)result;
79526   return jresult;
79527 }
79528
79529
79530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79531   int jresult ;
79532   int result;
79533
79534   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79535   jresult = (int)result;
79536   return jresult;
79537 }
79538
79539
79540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79541   int jresult ;
79542   int result;
79543
79544   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79545   jresult = (int)result;
79546   return jresult;
79547 }
79548
79549
79550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79551   int jresult ;
79552   int result;
79553
79554   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79555   jresult = (int)result;
79556   return jresult;
79557 }
79558
79559
79560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79561   int jresult ;
79562   int result;
79563
79564   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79565   jresult = (int)result;
79566   return jresult;
79567 }
79568
79569
79570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79571   int jresult ;
79572   int result;
79573
79574   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79575   jresult = (int)result;
79576   return jresult;
79577 }
79578
79579
79580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79581   void * jresult ;
79582   Dali::Toolkit::TextLabel::Property *result = 0 ;
79583
79584   {
79585     try {
79586       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79587     } catch (std::out_of_range& e) {
79588       {
79589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79590       };
79591     } catch (std::exception& e) {
79592       {
79593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (...) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79598       };
79599     }
79600   }
79601   jresult = (void *)result;
79602   return jresult;
79603 }
79604
79605
79606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79607   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79608
79609   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79610   {
79611     try {
79612       delete arg1;
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79620       };
79621     } catch (...) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79624       };
79625     }
79626   }
79627 }
79628
79629
79630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79631   void * jresult ;
79632   Dali::Toolkit::TextLabel result;
79633
79634   {
79635     try {
79636       result = Dali::Toolkit::TextLabel::New();
79637     } catch (std::out_of_range& e) {
79638       {
79639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (std::exception& e) {
79642       {
79643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (...) {
79646       {
79647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79648       };
79649     }
79650   }
79651   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79652   return jresult;
79653 }
79654
79655
79656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79657   void * jresult ;
79658   std::string *arg1 = 0 ;
79659   Dali::Toolkit::TextLabel result;
79660
79661   if (!jarg1) {
79662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79663     return 0;
79664   }
79665   std::string arg1_str(jarg1);
79666   arg1 = &arg1_str;
79667   {
79668     try {
79669       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79670     } catch (std::out_of_range& e) {
79671       {
79672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79673       };
79674     } catch (std::exception& e) {
79675       {
79676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79677       };
79678     } catch (...) {
79679       {
79680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79681       };
79682     }
79683   }
79684   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79685
79686   //argout typemap for const std::string&
79687
79688   return jresult;
79689 }
79690
79691
79692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79693   void * jresult ;
79694   Dali::Toolkit::TextLabel *result = 0 ;
79695
79696   {
79697     try {
79698       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79699     } catch (std::out_of_range& e) {
79700       {
79701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79702       };
79703     } catch (std::exception& e) {
79704       {
79705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79706       };
79707     } catch (...) {
79708       {
79709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79710       };
79711     }
79712   }
79713   jresult = (void *)result;
79714   return jresult;
79715 }
79716
79717
79718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79719   void * jresult ;
79720   Dali::Toolkit::TextLabel *arg1 = 0 ;
79721   Dali::Toolkit::TextLabel *result = 0 ;
79722
79723   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79724   if (!arg1) {
79725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79726     return 0;
79727   }
79728   {
79729     try {
79730       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79731     } catch (std::out_of_range& e) {
79732       {
79733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79734       };
79735     } catch (std::exception& e) {
79736       {
79737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79738       };
79739     } catch (...) {
79740       {
79741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79742       };
79743     }
79744   }
79745   jresult = (void *)result;
79746   return jresult;
79747 }
79748
79749
79750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79751   void * jresult ;
79752   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79753   Dali::Toolkit::TextLabel *arg2 = 0 ;
79754   Dali::Toolkit::TextLabel *result = 0 ;
79755
79756   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79757   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79758   if (!arg2) {
79759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79760     return 0;
79761   }
79762   {
79763     try {
79764       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79765     } catch (std::out_of_range& e) {
79766       {
79767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79768       };
79769     } catch (std::exception& e) {
79770       {
79771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79772       };
79773     } catch (...) {
79774       {
79775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79776       };
79777     }
79778   }
79779   jresult = (void *)result;
79780   return jresult;
79781 }
79782
79783
79784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79785   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79786
79787   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79788   {
79789     try {
79790       delete arg1;
79791     } catch (std::out_of_range& e) {
79792       {
79793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79794       };
79795     } catch (std::exception& e) {
79796       {
79797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79802       };
79803     }
79804   }
79805 }
79806
79807
79808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79809   void * jresult ;
79810   Dali::BaseHandle arg1 ;
79811   Dali::BaseHandle *argp1 ;
79812   Dali::Toolkit::TextLabel result;
79813
79814   argp1 = (Dali::BaseHandle *)jarg1;
79815   if (!argp1) {
79816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79817     return 0;
79818   }
79819   arg1 = *argp1;
79820   {
79821     try {
79822       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79823     } catch (std::out_of_range& e) {
79824       {
79825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79826       };
79827     } catch (std::exception& e) {
79828       {
79829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79830       };
79831     } catch (...) {
79832       {
79833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79834       };
79835     }
79836   }
79837   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79838   return jresult;
79839 }
79840
79841
79842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79843   void * jresult ;
79844   Dali::Toolkit::AccessibilityManager *result = 0 ;
79845
79846   {
79847     try {
79848       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79849     } catch (std::out_of_range& e) {
79850       {
79851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79852       };
79853     } catch (std::exception& e) {
79854       {
79855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79856       };
79857     } catch (...) {
79858       {
79859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79860       };
79861     }
79862   }
79863   jresult = (void *)result;
79864   return jresult;
79865 }
79866
79867
79868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79869   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79870
79871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79872   {
79873     try {
79874       delete arg1;
79875     } catch (std::out_of_range& e) {
79876       {
79877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79878       };
79879     } catch (std::exception& e) {
79880       {
79881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79882       };
79883     } catch (...) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79886       };
79887     }
79888   }
79889 }
79890
79891
79892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79893   void * jresult ;
79894   Dali::Toolkit::AccessibilityManager result;
79895
79896   {
79897     try {
79898       result = Dali::Toolkit::AccessibilityManager::Get();
79899     } catch (std::out_of_range& e) {
79900       {
79901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (std::exception& e) {
79904       {
79905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (...) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79910       };
79911     }
79912   }
79913   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79920   Dali::Actor arg2 ;
79921   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79922   std::string *arg4 = 0 ;
79923   Dali::Actor *argp2 ;
79924
79925   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79926   argp2 = (Dali::Actor *)jarg2;
79927   if (!argp2) {
79928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79929     return ;
79930   }
79931   arg2 = *argp2;
79932   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79933   if (!jarg4) {
79934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79935     return ;
79936   }
79937   std::string arg4_str(jarg4);
79938   arg4 = &arg4_str;
79939   {
79940     try {
79941       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79942     } catch (std::out_of_range& e) {
79943       {
79944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79945       };
79946     } catch (std::exception& e) {
79947       {
79948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79949       };
79950     } catch (...) {
79951       {
79952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79953       };
79954     }
79955   }
79956
79957   //argout typemap for const std::string&
79958
79959 }
79960
79961
79962 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79963   char * jresult ;
79964   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79965   Dali::Actor arg2 ;
79966   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79967   Dali::Actor *argp2 ;
79968   std::string result;
79969
79970   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79971   argp2 = (Dali::Actor *)jarg2;
79972   if (!argp2) {
79973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79974     return 0;
79975   }
79976   arg2 = *argp2;
79977   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79978   {
79979     try {
79980       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79981     } catch (std::out_of_range& e) {
79982       {
79983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (std::exception& e) {
79986       {
79987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79988       };
79989     } catch (...) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79992       };
79993     }
79994   }
79995   jresult = SWIG_csharp_string_callback((&result)->c_str());
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
80001   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80002   Dali::Actor arg2 ;
80003   unsigned int arg3 ;
80004   Dali::Actor *argp2 ;
80005
80006   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80007   argp2 = (Dali::Actor *)jarg2;
80008   if (!argp2) {
80009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80010     return ;
80011   }
80012   arg2 = *argp2;
80013   arg3 = (unsigned int)jarg3;
80014   {
80015     try {
80016       (arg1)->SetFocusOrder(arg2,arg3);
80017     } catch (std::out_of_range& e) {
80018       {
80019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80020       };
80021     } catch (std::exception& e) {
80022       {
80023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80024       };
80025     } catch (...) {
80026       {
80027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80028       };
80029     }
80030   }
80031 }
80032
80033
80034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
80035   unsigned int jresult ;
80036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80037   Dali::Actor arg2 ;
80038   Dali::Actor *argp2 ;
80039   unsigned int result;
80040
80041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80042   argp2 = (Dali::Actor *)jarg2;
80043   if (!argp2) {
80044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80045     return 0;
80046   }
80047   arg2 = *argp2;
80048   {
80049     try {
80050       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
80051     } catch (std::out_of_range& e) {
80052       {
80053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80054       };
80055     } catch (std::exception& e) {
80056       {
80057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80058       };
80059     } catch (...) {
80060       {
80061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80062       };
80063     }
80064   }
80065   jresult = result;
80066   return jresult;
80067 }
80068
80069
80070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80071   unsigned int jresult ;
80072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80073   unsigned int result;
80074
80075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80076   {
80077     try {
80078       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80079     } catch (std::out_of_range& e) {
80080       {
80081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (std::exception& e) {
80084       {
80085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80090       };
80091     }
80092   }
80093   jresult = result;
80094   return jresult;
80095 }
80096
80097
80098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80099   void * jresult ;
80100   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80101   unsigned int arg2 ;
80102   Dali::Actor result;
80103
80104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80105   arg2 = (unsigned int)jarg2;
80106   {
80107     try {
80108       result = (arg1)->GetActorByFocusOrder(arg2);
80109     } catch (std::out_of_range& e) {
80110       {
80111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (std::exception& e) {
80114       {
80115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (...) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80120       };
80121     }
80122   }
80123   jresult = new Dali::Actor((const Dali::Actor &)result);
80124   return jresult;
80125 }
80126
80127
80128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80129   unsigned int jresult ;
80130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80131   Dali::Actor arg2 ;
80132   Dali::Actor *argp2 ;
80133   bool result;
80134
80135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80136   argp2 = (Dali::Actor *)jarg2;
80137   if (!argp2) {
80138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80139     return 0;
80140   }
80141   arg2 = *argp2;
80142   {
80143     try {
80144       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80145     } catch (std::out_of_range& e) {
80146       {
80147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80148       };
80149     } catch (std::exception& e) {
80150       {
80151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80152       };
80153     } catch (...) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80156       };
80157     }
80158   }
80159   jresult = result;
80160   return jresult;
80161 }
80162
80163
80164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80165   void * jresult ;
80166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80167   Dali::Actor result;
80168
80169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80170   {
80171     try {
80172       result = (arg1)->GetCurrentFocusActor();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80184       };
80185     }
80186   }
80187   jresult = new Dali::Actor((const Dali::Actor &)result);
80188   return jresult;
80189 }
80190
80191
80192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80193   void * jresult ;
80194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80195   Dali::Actor result;
80196
80197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80198   {
80199     try {
80200       result = (arg1)->GetCurrentFocusGroup();
80201     } catch (std::out_of_range& e) {
80202       {
80203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (std::exception& e) {
80206       {
80207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80208       };
80209     } catch (...) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80212       };
80213     }
80214   }
80215   jresult = new Dali::Actor((const Dali::Actor &)result);
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80221   unsigned int jresult ;
80222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80223   unsigned int result;
80224
80225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80226   {
80227     try {
80228       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (...) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80240       };
80241     }
80242   }
80243   jresult = result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80249   unsigned int jresult ;
80250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80251   bool result;
80252
80253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80254   {
80255     try {
80256       result = (bool)(arg1)->MoveFocusForward();
80257     } catch (std::out_of_range& e) {
80258       {
80259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80260       };
80261     } catch (std::exception& e) {
80262       {
80263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80268       };
80269     }
80270   }
80271   jresult = result;
80272   return jresult;
80273 }
80274
80275
80276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80277   unsigned int jresult ;
80278   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80279   bool result;
80280
80281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80282   {
80283     try {
80284       result = (bool)(arg1)->MoveFocusBackward();
80285     } catch (std::out_of_range& e) {
80286       {
80287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80288       };
80289     } catch (std::exception& e) {
80290       {
80291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80292       };
80293     } catch (...) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80296       };
80297     }
80298   }
80299   jresult = result;
80300   return jresult;
80301 }
80302
80303
80304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80305   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80306
80307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80308   {
80309     try {
80310       (arg1)->ClearFocus();
80311     } catch (std::out_of_range& e) {
80312       {
80313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80314       };
80315     } catch (std::exception& e) {
80316       {
80317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80318       };
80319     } catch (...) {
80320       {
80321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80322       };
80323     }
80324   }
80325 }
80326
80327
80328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80329   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80330
80331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80332   {
80333     try {
80334       (arg1)->Reset();
80335     } catch (std::out_of_range& e) {
80336       {
80337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80338       };
80339     } catch (std::exception& e) {
80340       {
80341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80342       };
80343     } catch (...) {
80344       {
80345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80346       };
80347     }
80348   }
80349 }
80350
80351
80352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80354   Dali::Actor arg2 ;
80355   bool arg3 ;
80356   Dali::Actor *argp2 ;
80357
80358   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80359   argp2 = (Dali::Actor *)jarg2;
80360   if (!argp2) {
80361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80362     return ;
80363   }
80364   arg2 = *argp2;
80365   arg3 = jarg3 ? true : false;
80366   {
80367     try {
80368       (arg1)->SetFocusGroup(arg2,arg3);
80369     } catch (std::out_of_range& e) {
80370       {
80371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80372       };
80373     } catch (std::exception& e) {
80374       {
80375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80376       };
80377     } catch (...) {
80378       {
80379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80380       };
80381     }
80382   }
80383 }
80384
80385
80386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80387   unsigned int jresult ;
80388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80389   Dali::Actor arg2 ;
80390   Dali::Actor *argp2 ;
80391   bool result;
80392
80393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80394   argp2 = (Dali::Actor *)jarg2;
80395   if (!argp2) {
80396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80397     return 0;
80398   }
80399   arg2 = *argp2;
80400   {
80401     try {
80402       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80403     } catch (std::out_of_range& e) {
80404       {
80405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80406       };
80407     } catch (std::exception& e) {
80408       {
80409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (...) {
80412       {
80413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80414       };
80415     }
80416   }
80417   jresult = result;
80418   return jresult;
80419 }
80420
80421
80422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80424   bool arg2 ;
80425
80426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80427   arg2 = jarg2 ? true : false;
80428   {
80429     try {
80430       (arg1)->SetGroupMode(arg2);
80431     } catch (std::out_of_range& e) {
80432       {
80433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80434       };
80435     } catch (std::exception& e) {
80436       {
80437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80438       };
80439     } catch (...) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80442       };
80443     }
80444   }
80445 }
80446
80447
80448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80449   unsigned int jresult ;
80450   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80451   bool result;
80452
80453   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80454   {
80455     try {
80456       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80457     } catch (std::out_of_range& e) {
80458       {
80459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80460       };
80461     } catch (std::exception& e) {
80462       {
80463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80464       };
80465     } catch (...) {
80466       {
80467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80468       };
80469     }
80470   }
80471   jresult = result;
80472   return jresult;
80473 }
80474
80475
80476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80477   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80478   bool arg2 ;
80479
80480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80481   arg2 = jarg2 ? true : false;
80482   {
80483     try {
80484       (arg1)->SetWrapMode(arg2);
80485     } catch (std::out_of_range& e) {
80486       {
80487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80488       };
80489     } catch (std::exception& e) {
80490       {
80491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80492       };
80493     } catch (...) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80496       };
80497     }
80498   }
80499 }
80500
80501
80502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80503   unsigned int jresult ;
80504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80505   bool result;
80506
80507   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80508   {
80509     try {
80510       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80511     } catch (std::out_of_range& e) {
80512       {
80513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80514       };
80515     } catch (std::exception& e) {
80516       {
80517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80518       };
80519     } catch (...) {
80520       {
80521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80522       };
80523     }
80524   }
80525   jresult = result;
80526   return jresult;
80527 }
80528
80529
80530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80532   Dali::Actor arg2 ;
80533   Dali::Actor *argp2 ;
80534
80535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80536   argp2 = (Dali::Actor *)jarg2;
80537   if (!argp2) {
80538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80539     return ;
80540   }
80541   arg2 = *argp2;
80542   {
80543     try {
80544       (arg1)->SetFocusIndicatorActor(arg2);
80545     } catch (std::out_of_range& e) {
80546       {
80547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80548       };
80549     } catch (std::exception& e) {
80550       {
80551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80556       };
80557     }
80558   }
80559 }
80560
80561
80562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80563   void * jresult ;
80564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80565   Dali::Actor result;
80566
80567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80568   {
80569     try {
80570       result = (arg1)->GetFocusIndicatorActor();
80571     } catch (std::out_of_range& e) {
80572       {
80573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80574       };
80575     } catch (std::exception& e) {
80576       {
80577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80578       };
80579     } catch (...) {
80580       {
80581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80582       };
80583     }
80584   }
80585   jresult = new Dali::Actor((const Dali::Actor &)result);
80586   return jresult;
80587 }
80588
80589
80590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80591   void * jresult ;
80592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80593   Dali::Actor arg2 ;
80594   Dali::Actor *argp2 ;
80595   Dali::Actor result;
80596
80597   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80598   argp2 = (Dali::Actor *)jarg2;
80599   if (!argp2) {
80600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80601     return 0;
80602   }
80603   arg2 = *argp2;
80604   {
80605     try {
80606       result = (arg1)->GetFocusGroup(arg2);
80607     } catch (std::out_of_range& e) {
80608       {
80609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80610       };
80611     } catch (std::exception& e) {
80612       {
80613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80614       };
80615     } catch (...) {
80616       {
80617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80618       };
80619     }
80620   }
80621   jresult = new Dali::Actor((const Dali::Actor &)result);
80622   return jresult;
80623 }
80624
80625
80626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80627   void * jresult ;
80628   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80629   Dali::Vector2 result;
80630
80631   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80632   {
80633     try {
80634       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80635     } catch (std::out_of_range& e) {
80636       {
80637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80638       };
80639     } catch (std::exception& e) {
80640       {
80641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80642       };
80643     } catch (...) {
80644       {
80645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80646       };
80647     }
80648   }
80649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80650   return jresult;
80651 }
80652
80653
80654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80655   void * jresult ;
80656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80657   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80658
80659   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80660   {
80661     try {
80662       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80663     } catch (std::out_of_range& e) {
80664       {
80665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80666       };
80667     } catch (std::exception& e) {
80668       {
80669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80670       };
80671     } catch (...) {
80672       {
80673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80674       };
80675     }
80676   }
80677   jresult = (void *)result;
80678   return jresult;
80679 }
80680
80681
80682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80683   void * jresult ;
80684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80685   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80686
80687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80688   {
80689     try {
80690       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80691     } catch (std::out_of_range& e) {
80692       {
80693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80694       };
80695     } catch (std::exception& e) {
80696       {
80697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80698       };
80699     } catch (...) {
80700       {
80701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80702       };
80703     }
80704   }
80705   jresult = (void *)result;
80706   return jresult;
80707 }
80708
80709
80710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80711   void * jresult ;
80712   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80713   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80714
80715   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80716   {
80717     try {
80718       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80719     } catch (std::out_of_range& e) {
80720       {
80721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80722       };
80723     } catch (std::exception& e) {
80724       {
80725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80726       };
80727     } catch (...) {
80728       {
80729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80730       };
80731     }
80732   }
80733   jresult = (void *)result;
80734   return jresult;
80735 }
80736
80737
80738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80739   void * jresult ;
80740   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80741   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80742
80743   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80744   {
80745     try {
80746       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80747     } catch (std::out_of_range& e) {
80748       {
80749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80750       };
80751     } catch (std::exception& e) {
80752       {
80753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80754       };
80755     } catch (...) {
80756       {
80757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80758       };
80759     }
80760   }
80761   jresult = (void *)result;
80762   return jresult;
80763 }
80764
80765
80766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80767   void * jresult ;
80768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80769   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80770
80771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80772   {
80773     try {
80774       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80775     } catch (std::out_of_range& e) {
80776       {
80777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80778       };
80779     } catch (std::exception& e) {
80780       {
80781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80782       };
80783     } catch (...) {
80784       {
80785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80786       };
80787     }
80788   }
80789   jresult = (void *)result;
80790   return jresult;
80791 }
80792
80793
80794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80795   void * jresult ;
80796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80797   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80798
80799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80800   {
80801     try {
80802       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80803     } catch (std::out_of_range& e) {
80804       {
80805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80806       };
80807     } catch (std::exception& e) {
80808       {
80809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80810       };
80811     } catch (...) {
80812       {
80813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80814       };
80815     }
80816   }
80817   jresult = (void *)result;
80818   return jresult;
80819 }
80820
80821
80822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80823   void * jresult ;
80824   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80825   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80826
80827   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80828   {
80829     try {
80830       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80831     } catch (std::out_of_range& e) {
80832       {
80833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80834       };
80835     } catch (std::exception& e) {
80836       {
80837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80838       };
80839     } catch (...) {
80840       {
80841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80842       };
80843     }
80844   }
80845   jresult = (void *)result;
80846   return jresult;
80847 }
80848
80849
80850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80851   void * jresult ;
80852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80853   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80854
80855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80856   {
80857     try {
80858       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80859     } catch (std::out_of_range& e) {
80860       {
80861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (std::exception& e) {
80864       {
80865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80866       };
80867     } catch (...) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80870       };
80871     }
80872   }
80873   jresult = (void *)result;
80874   return jresult;
80875 }
80876
80877
80878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80879   void * jresult ;
80880   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80881   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80882
80883   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80884   {
80885     try {
80886       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80887     } catch (std::out_of_range& e) {
80888       {
80889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80890       };
80891     } catch (std::exception& e) {
80892       {
80893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80894       };
80895     } catch (...) {
80896       {
80897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80898       };
80899     }
80900   }
80901   jresult = (void *)result;
80902   return jresult;
80903 }
80904
80905
80906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80907   void * jresult ;
80908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80909   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80910
80911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80912   {
80913     try {
80914       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80915     } catch (std::out_of_range& e) {
80916       {
80917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (std::exception& e) {
80920       {
80921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (...) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80926       };
80927     }
80928   }
80929   jresult = (void *)result;
80930   return jresult;
80931 }
80932
80933
80934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80935   void * jresult ;
80936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80938
80939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80940   {
80941     try {
80942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80943     } catch (std::out_of_range& e) {
80944       {
80945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (std::exception& e) {
80948       {
80949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (...) {
80952       {
80953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80954       };
80955     }
80956   }
80957   jresult = (void *)result;
80958   return jresult;
80959 }
80960
80961
80962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80963   void * jresult ;
80964   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80965   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80966
80967   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80968   {
80969     try {
80970       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80971     } catch (std::out_of_range& e) {
80972       {
80973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (std::exception& e) {
80976       {
80977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (...) {
80980       {
80981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80982       };
80983     }
80984   }
80985   jresult = (void *)result;
80986   return jresult;
80987 }
80988
80989
80990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80991   void * jresult ;
80992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80993   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80994
80995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80996   {
80997     try {
80998       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80999     } catch (std::out_of_range& e) {
81000       {
81001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81002       };
81003     } catch (std::exception& e) {
81004       {
81005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (...) {
81008       {
81009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81010       };
81011     }
81012   }
81013   jresult = (void *)result;
81014   return jresult;
81015 }
81016
81017
81018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
81019   void * jresult ;
81020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81021   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81022
81023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81024   {
81025     try {
81026       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
81027     } catch (std::out_of_range& e) {
81028       {
81029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81030       };
81031     } catch (std::exception& e) {
81032       {
81033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81034       };
81035     } catch (...) {
81036       {
81037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81038       };
81039     }
81040   }
81041   jresult = (void *)result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81047   void * jresult ;
81048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81050
81051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81052   {
81053     try {
81054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81055     } catch (std::out_of_range& e) {
81056       {
81057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81058       };
81059     } catch (std::exception& e) {
81060       {
81061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81062       };
81063     } catch (...) {
81064       {
81065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81066       };
81067     }
81068   }
81069   jresult = (void *)result;
81070   return jresult;
81071 }
81072
81073
81074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81075   void * jresult ;
81076   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81077   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81078
81079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81080   {
81081     try {
81082       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81083     } catch (std::out_of_range& e) {
81084       {
81085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81086       };
81087     } catch (std::exception& e) {
81088       {
81089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81090       };
81091     } catch (...) {
81092       {
81093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81094       };
81095     }
81096   }
81097   jresult = (void *)result;
81098   return jresult;
81099 }
81100
81101
81102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81103   void * jresult ;
81104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81105   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81106
81107   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81108   {
81109     try {
81110       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81111     } catch (std::out_of_range& e) {
81112       {
81113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81114       };
81115     } catch (std::exception& e) {
81116       {
81117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81122       };
81123     }
81124   }
81125   jresult = (void *)result;
81126   return jresult;
81127 }
81128
81129
81130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81131   void * jresult ;
81132   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81133   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81134
81135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81136   {
81137     try {
81138       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81139     } catch (std::out_of_range& e) {
81140       {
81141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81142       };
81143     } catch (std::exception& e) {
81144       {
81145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81146       };
81147     } catch (...) {
81148       {
81149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81150       };
81151     }
81152   }
81153   jresult = (void *)result;
81154   return jresult;
81155 }
81156
81157
81158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81159   void * jresult ;
81160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81161   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81162
81163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81164   {
81165     try {
81166       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81167     } catch (std::out_of_range& e) {
81168       {
81169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81170       };
81171     } catch (std::exception& e) {
81172       {
81173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81174       };
81175     } catch (...) {
81176       {
81177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81178       };
81179     }
81180   }
81181   jresult = (void *)result;
81182   return jresult;
81183 }
81184
81185
81186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81187   void * jresult ;
81188   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81189   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81190
81191   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81192   {
81193     try {
81194       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81195     } catch (std::out_of_range& e) {
81196       {
81197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81198       };
81199     } catch (std::exception& e) {
81200       {
81201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81202       };
81203     } catch (...) {
81204       {
81205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81206       };
81207     }
81208   }
81209   jresult = (void *)result;
81210   return jresult;
81211 }
81212
81213
81214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81215   void * jresult ;
81216   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81217   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81218
81219   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81220   {
81221     try {
81222       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81223     } catch (std::out_of_range& e) {
81224       {
81225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81226       };
81227     } catch (std::exception& e) {
81228       {
81229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (...) {
81232       {
81233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81234       };
81235     }
81236   }
81237   jresult = (void *)result;
81238   return jresult;
81239 }
81240
81241
81242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81243   void * jresult ;
81244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81245   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81246
81247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81248   {
81249     try {
81250       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81251     } catch (std::out_of_range& e) {
81252       {
81253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81254       };
81255     } catch (std::exception& e) {
81256       {
81257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (...) {
81260       {
81261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81262       };
81263     }
81264   }
81265   jresult = (void *)result;
81266   return jresult;
81267 }
81268
81269
81270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81271   void * jresult ;
81272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81273   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81274
81275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81276   {
81277     try {
81278       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81279     } catch (std::out_of_range& e) {
81280       {
81281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81282       };
81283     } catch (std::exception& e) {
81284       {
81285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81286       };
81287     } catch (...) {
81288       {
81289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81290       };
81291     }
81292   }
81293   jresult = (void *)result;
81294   return jresult;
81295 }
81296
81297
81298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81299   void * jresult ;
81300   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81301   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81302
81303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81304   {
81305     try {
81306       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81307     } catch (std::out_of_range& e) {
81308       {
81309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81310       };
81311     } catch (std::exception& e) {
81312       {
81313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81314       };
81315     } catch (...) {
81316       {
81317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81318       };
81319     }
81320   }
81321   jresult = (void *)result;
81322   return jresult;
81323 }
81324
81325
81326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81327   void * jresult ;
81328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81329   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81330
81331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81332   {
81333     try {
81334       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81335     } catch (std::out_of_range& e) {
81336       {
81337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81338       };
81339     } catch (std::exception& e) {
81340       {
81341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81342       };
81343     } catch (...) {
81344       {
81345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81346       };
81347     }
81348   }
81349   jresult = (void *)result;
81350   return jresult;
81351 }
81352
81353
81354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81355   void * jresult ;
81356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81357   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81358
81359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81360   {
81361     try {
81362       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81363     } catch (std::out_of_range& e) {
81364       {
81365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81366       };
81367     } catch (std::exception& e) {
81368       {
81369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81370       };
81371     } catch (...) {
81372       {
81373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81374       };
81375     }
81376   }
81377   jresult = (void *)result;
81378   return jresult;
81379 }
81380
81381
81382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81383   void * jresult ;
81384   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81385   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81386
81387   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81388   {
81389     try {
81390       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81391     } catch (std::out_of_range& e) {
81392       {
81393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81394       };
81395     } catch (std::exception& e) {
81396       {
81397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81398       };
81399     } catch (...) {
81400       {
81401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81402       };
81403     }
81404   }
81405   jresult = (void *)result;
81406   return jresult;
81407 }
81408
81409
81410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81411   void * jresult ;
81412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81413   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81414
81415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81416   {
81417     try {
81418       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81419     } catch (std::out_of_range& e) {
81420       {
81421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81422       };
81423     } catch (std::exception& e) {
81424       {
81425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81426       };
81427     } catch (...) {
81428       {
81429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81430       };
81431     }
81432   }
81433   jresult = (void *)result;
81434   return jresult;
81435 }
81436
81437
81438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81439   void * jresult ;
81440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81441   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81442
81443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81444   {
81445     try {
81446       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81447     } catch (std::out_of_range& e) {
81448       {
81449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81450       };
81451     } catch (std::exception& e) {
81452       {
81453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81458       };
81459     }
81460   }
81461   jresult = (void *)result;
81462   return jresult;
81463 }
81464
81465
81466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81467   void * jresult ;
81468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81469   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81470
81471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81472   {
81473     try {
81474       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81475     } catch (std::out_of_range& e) {
81476       {
81477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81478       };
81479     } catch (std::exception& e) {
81480       {
81481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81482       };
81483     } catch (...) {
81484       {
81485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81486       };
81487     }
81488   }
81489   jresult = (void *)result;
81490   return jresult;
81491 }
81492
81493
81494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81495   void * jresult ;
81496   Dali::Toolkit::StyleManager *result = 0 ;
81497
81498   {
81499     try {
81500       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81508       };
81509     } catch (...) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81512       };
81513     }
81514   }
81515   jresult = (void *)result;
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81521   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81522
81523   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81524   {
81525     try {
81526       delete arg1;
81527     } catch (std::out_of_range& e) {
81528       {
81529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81530       };
81531     } catch (std::exception& e) {
81532       {
81533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81534       };
81535     } catch (...) {
81536       {
81537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81538       };
81539     }
81540   }
81541 }
81542
81543
81544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81545   void * jresult ;
81546   Dali::Toolkit::StyleManager result;
81547
81548   {
81549     try {
81550       result = Dali::Toolkit::StyleManager::Get();
81551     } catch (std::out_of_range& e) {
81552       {
81553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81554       };
81555     } catch (std::exception& e) {
81556       {
81557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81558       };
81559     } catch (...) {
81560       {
81561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81562       };
81563     }
81564   }
81565   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81566   return jresult;
81567 }
81568
81569
81570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81571   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81572   std::string *arg2 = 0 ;
81573
81574   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81575   if (!jarg2) {
81576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81577     return ;
81578   }
81579   std::string arg2_str(jarg2);
81580   arg2 = &arg2_str;
81581   {
81582     try {
81583       (arg1)->ApplyTheme((std::string const &)*arg2);
81584     } catch (std::out_of_range& e) {
81585       {
81586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81587       };
81588     } catch (std::exception& e) {
81589       {
81590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81591       };
81592     } catch (...) {
81593       {
81594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81595       };
81596     }
81597   }
81598
81599   //argout typemap for const std::string&
81600
81601 }
81602
81603
81604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81605   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81606
81607   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81608   {
81609     try {
81610       (arg1)->ApplyDefaultTheme();
81611     } catch (std::out_of_range& e) {
81612       {
81613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81614       };
81615     } catch (std::exception& e) {
81616       {
81617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81618       };
81619     } catch (...) {
81620       {
81621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81622       };
81623     }
81624   }
81625 }
81626
81627
81628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81629   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81630   std::string *arg2 = 0 ;
81631   Dali::Property::Value *arg3 = 0 ;
81632
81633   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81634   if (!jarg2) {
81635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81636     return ;
81637   }
81638   std::string arg2_str(jarg2);
81639   arg2 = &arg2_str;
81640   arg3 = (Dali::Property::Value *)jarg3;
81641   if (!arg3) {
81642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81643     return ;
81644   }
81645   {
81646     try {
81647       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81648     } catch (std::out_of_range& e) {
81649       {
81650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81651       };
81652     } catch (std::exception& e) {
81653       {
81654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81655       };
81656     } catch (...) {
81657       {
81658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81659       };
81660     }
81661   }
81662
81663   //argout typemap for const std::string&
81664
81665 }
81666
81667
81668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81669   unsigned int jresult ;
81670   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81671   std::string *arg2 = 0 ;
81672   Dali::Property::Value *arg3 = 0 ;
81673   bool result;
81674
81675   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81676   if (!jarg2) {
81677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81678     return 0;
81679   }
81680   std::string arg2_str(jarg2);
81681   arg2 = &arg2_str;
81682   arg3 = (Dali::Property::Value *)jarg3;
81683   if (!arg3) {
81684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81685     return 0;
81686   }
81687   {
81688     try {
81689       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81690     } catch (std::out_of_range& e) {
81691       {
81692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81693       };
81694     } catch (std::exception& e) {
81695       {
81696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81697       };
81698     } catch (...) {
81699       {
81700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81701       };
81702     }
81703   }
81704   jresult = result;
81705
81706   //argout typemap for const std::string&
81707
81708   return jresult;
81709 }
81710
81711
81712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81713   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81714   Dali::Toolkit::Control arg2 ;
81715   std::string *arg3 = 0 ;
81716   std::string *arg4 = 0 ;
81717   Dali::Toolkit::Control *argp2 ;
81718
81719   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81720   argp2 = (Dali::Toolkit::Control *)jarg2;
81721   if (!argp2) {
81722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81723     return ;
81724   }
81725   arg2 = *argp2;
81726   if (!jarg3) {
81727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81728     return ;
81729   }
81730   std::string arg3_str(jarg3);
81731   arg3 = &arg3_str;
81732   if (!jarg4) {
81733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81734     return ;
81735   }
81736   std::string arg4_str(jarg4);
81737   arg4 = &arg4_str;
81738   {
81739     try {
81740       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81741     } catch (std::out_of_range& e) {
81742       {
81743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (std::exception& e) {
81746       {
81747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81748       };
81749     } catch (...) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81752       };
81753     }
81754   }
81755
81756   //argout typemap for const std::string&
81757
81758
81759   //argout typemap for const std::string&
81760
81761 }
81762
81763
81764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81765   void * jresult ;
81766   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81767   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81768
81769   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81770   {
81771     try {
81772       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81773     } catch (std::out_of_range& e) {
81774       {
81775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81776       };
81777     } catch (std::exception& e) {
81778       {
81779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81780       };
81781     } catch (...) {
81782       {
81783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81784       };
81785     }
81786   }
81787   jresult = (void *)result;
81788   return jresult;
81789 }
81790
81791
81792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81793   int jresult ;
81794   int result;
81795
81796   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81797   jresult = (int)result;
81798   return jresult;
81799 }
81800
81801
81802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81803   int jresult ;
81804   int result;
81805
81806   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81807   jresult = (int)result;
81808   return jresult;
81809 }
81810
81811
81812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81813   int jresult ;
81814   int result;
81815
81816   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81817   jresult = (int)result;
81818   return jresult;
81819 }
81820
81821
81822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81823   int jresult ;
81824   int result;
81825
81826   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81827   jresult = (int)result;
81828   return jresult;
81829 }
81830
81831
81832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81833   int jresult ;
81834   int result;
81835
81836   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81837   jresult = (int)result;
81838   return jresult;
81839 }
81840
81841
81842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81843   int jresult ;
81844   int result;
81845
81846   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81847   jresult = (int)result;
81848   return jresult;
81849 }
81850
81851
81852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81853   int jresult ;
81854   int result;
81855
81856   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81857   jresult = (int)result;
81858   return jresult;
81859 }
81860
81861
81862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81863   int jresult ;
81864   int result;
81865
81866   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81867   jresult = (int)result;
81868   return jresult;
81869 }
81870
81871
81872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81873   int jresult ;
81874   int result;
81875
81876   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81877   jresult = (int)result;
81878   return jresult;
81879 }
81880
81881
81882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81883   int jresult ;
81884   int result;
81885
81886   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81887   jresult = (int)result;
81888   return jresult;
81889 }
81890
81891
81892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81893   int jresult ;
81894   int result;
81895
81896   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81897   jresult = (int)result;
81898   return jresult;
81899 }
81900
81901
81902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81903   int jresult ;
81904   int result;
81905
81906   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81907   jresult = (int)result;
81908   return jresult;
81909 }
81910
81911
81912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81913   int jresult ;
81914   int result;
81915
81916   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81917   jresult = (int)result;
81918   return jresult;
81919 }
81920
81921
81922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81923   int jresult ;
81924   int result;
81925
81926   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81927   jresult = (int)result;
81928   return jresult;
81929 }
81930
81931
81932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81933   int jresult ;
81934   int result;
81935
81936   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81937   jresult = (int)result;
81938   return jresult;
81939 }
81940
81941
81942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81943   void * jresult ;
81944   Dali::Toolkit::Slider::Property *result = 0 ;
81945
81946   {
81947     try {
81948       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81960       };
81961     }
81962   }
81963   jresult = (void *)result;
81964   return jresult;
81965 }
81966
81967
81968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81969   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81970
81971   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81972   {
81973     try {
81974       delete arg1;
81975     } catch (std::out_of_range& e) {
81976       {
81977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81978       };
81979     } catch (std::exception& e) {
81980       {
81981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (...) {
81984       {
81985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81986       };
81987     }
81988   }
81989 }
81990
81991
81992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81993   void * jresult ;
81994   Dali::Toolkit::Slider result;
81995
81996   {
81997     try {
81998       result = Dali::Toolkit::Slider::New();
81999     } catch (std::out_of_range& e) {
82000       {
82001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82002       };
82003     } catch (std::exception& e) {
82004       {
82005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82006       };
82007     } catch (...) {
82008       {
82009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82010       };
82011     }
82012   }
82013   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82014   return jresult;
82015 }
82016
82017
82018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
82019   void * jresult ;
82020   Dali::Toolkit::Slider *result = 0 ;
82021
82022   {
82023     try {
82024       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
82025     } catch (std::out_of_range& e) {
82026       {
82027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82028       };
82029     } catch (std::exception& e) {
82030       {
82031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82032       };
82033     } catch (...) {
82034       {
82035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82036       };
82037     }
82038   }
82039   jresult = (void *)result;
82040   return jresult;
82041 }
82042
82043
82044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
82045   void * jresult ;
82046   Dali::Toolkit::Slider *arg1 = 0 ;
82047   Dali::Toolkit::Slider *result = 0 ;
82048
82049   arg1 = (Dali::Toolkit::Slider *)jarg1;
82050   if (!arg1) {
82051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82052     return 0;
82053   }
82054   {
82055     try {
82056       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
82057     } catch (std::out_of_range& e) {
82058       {
82059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82060       };
82061     } catch (std::exception& e) {
82062       {
82063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (...) {
82066       {
82067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82068       };
82069     }
82070   }
82071   jresult = (void *)result;
82072   return jresult;
82073 }
82074
82075
82076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82077   void * jresult ;
82078   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82079   Dali::Toolkit::Slider *arg2 = 0 ;
82080   Dali::Toolkit::Slider *result = 0 ;
82081
82082   arg1 = (Dali::Toolkit::Slider *)jarg1;
82083   arg2 = (Dali::Toolkit::Slider *)jarg2;
82084   if (!arg2) {
82085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82086     return 0;
82087   }
82088   {
82089     try {
82090       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82091     } catch (std::out_of_range& e) {
82092       {
82093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82094       };
82095     } catch (std::exception& e) {
82096       {
82097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82098       };
82099     } catch (...) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82102       };
82103     }
82104   }
82105   jresult = (void *)result;
82106   return jresult;
82107 }
82108
82109
82110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82111   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82112
82113   arg1 = (Dali::Toolkit::Slider *)jarg1;
82114   {
82115     try {
82116       delete arg1;
82117     } catch (std::out_of_range& e) {
82118       {
82119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82120       };
82121     } catch (std::exception& e) {
82122       {
82123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82124       };
82125     } catch (...) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82128       };
82129     }
82130   }
82131 }
82132
82133
82134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82135   void * jresult ;
82136   Dali::BaseHandle arg1 ;
82137   Dali::BaseHandle *argp1 ;
82138   Dali::Toolkit::Slider result;
82139
82140   argp1 = (Dali::BaseHandle *)jarg1;
82141   if (!argp1) {
82142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82143     return 0;
82144   }
82145   arg1 = *argp1;
82146   {
82147     try {
82148       result = Dali::Toolkit::Slider::DownCast(arg1);
82149     } catch (std::out_of_range& e) {
82150       {
82151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (std::exception& e) {
82154       {
82155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82160       };
82161     }
82162   }
82163   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82164   return jresult;
82165 }
82166
82167
82168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82169   void * jresult ;
82170   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82171   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82172
82173   arg1 = (Dali::Toolkit::Slider *)jarg1;
82174   {
82175     try {
82176       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82177     } catch (std::out_of_range& e) {
82178       {
82179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82180       };
82181     } catch (std::exception& e) {
82182       {
82183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82184       };
82185     } catch (...) {
82186       {
82187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82188       };
82189     }
82190   }
82191   jresult = (void *)result;
82192   return jresult;
82193 }
82194
82195
82196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82197   void * jresult ;
82198   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82199   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82200
82201   arg1 = (Dali::Toolkit::Slider *)jarg1;
82202   {
82203     try {
82204       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82205     } catch (std::out_of_range& e) {
82206       {
82207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82208       };
82209     } catch (std::exception& e) {
82210       {
82211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82212       };
82213     } catch (...) {
82214       {
82215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82216       };
82217     }
82218   }
82219   jresult = (void *)result;
82220   return jresult;
82221 }
82222
82223
82224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82225   void * jresult ;
82226   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82227   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82228
82229   arg1 = (Dali::Toolkit::Slider *)jarg1;
82230   {
82231     try {
82232       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82233     } catch (std::out_of_range& e) {
82234       {
82235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82236       };
82237     } catch (std::exception& e) {
82238       {
82239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82240       };
82241     } catch (...) {
82242       {
82243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82244       };
82245     }
82246   }
82247   jresult = (void *)result;
82248   return jresult;
82249 }
82250
82251
82252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82253   int jresult ;
82254   int result;
82255
82256   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82257   jresult = (int)result;
82258   return jresult;
82259 }
82260
82261
82262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82263   int jresult ;
82264   int result;
82265
82266   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82267   jresult = (int)result;
82268   return jresult;
82269 }
82270
82271
82272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82273   int jresult ;
82274   int result;
82275
82276   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82277   jresult = (int)result;
82278   return jresult;
82279 }
82280
82281
82282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82283   int jresult ;
82284   int result;
82285
82286   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82287   jresult = (int)result;
82288   return jresult;
82289 }
82290
82291
82292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82293   void * jresult ;
82294   Dali::Toolkit::VideoView::Property *result = 0 ;
82295
82296   {
82297     try {
82298       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82299     } catch (std::out_of_range& e) {
82300       {
82301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82302       };
82303     } catch (std::exception& e) {
82304       {
82305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82310       };
82311     }
82312   }
82313   jresult = (void *)result;
82314   return jresult;
82315 }
82316
82317
82318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82319   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82320
82321   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82322   {
82323     try {
82324       delete arg1;
82325     } catch (std::out_of_range& e) {
82326       {
82327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82328       };
82329     } catch (std::exception& e) {
82330       {
82331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82332       };
82333     } catch (...) {
82334       {
82335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82336       };
82337     }
82338   }
82339 }
82340
82341
82342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82343   void * jresult ;
82344   Dali::Toolkit::VideoView result;
82345
82346   {
82347     try {
82348       result = Dali::Toolkit::VideoView::New();
82349     } catch (std::out_of_range& e) {
82350       {
82351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82352       };
82353     } catch (std::exception& e) {
82354       {
82355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82356       };
82357     } catch (...) {
82358       {
82359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82360       };
82361     }
82362   }
82363   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82364   return jresult;
82365 }
82366
82367
82368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82369   void * jresult ;
82370   std::string *arg1 = 0 ;
82371   Dali::Toolkit::VideoView result;
82372
82373   if (!jarg1) {
82374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82375     return 0;
82376   }
82377   std::string arg1_str(jarg1);
82378   arg1 = &arg1_str;
82379   {
82380     try {
82381       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82389       };
82390     } catch (...) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82393       };
82394     }
82395   }
82396   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82397
82398   //argout typemap for const std::string&
82399
82400   return jresult;
82401 }
82402
82403
82404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82405   void * jresult ;
82406   Dali::Toolkit::VideoView *result = 0 ;
82407
82408   {
82409     try {
82410       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82411     } catch (std::out_of_range& e) {
82412       {
82413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82414       };
82415     } catch (std::exception& e) {
82416       {
82417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82418       };
82419     } catch (...) {
82420       {
82421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82422       };
82423     }
82424   }
82425   jresult = (void *)result;
82426   return jresult;
82427 }
82428
82429
82430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82431   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82432
82433   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82434   {
82435     try {
82436       delete arg1;
82437     } catch (std::out_of_range& e) {
82438       {
82439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82440       };
82441     } catch (std::exception& e) {
82442       {
82443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82444       };
82445     } catch (...) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82448       };
82449     }
82450   }
82451 }
82452
82453
82454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82455   void * jresult ;
82456   Dali::Toolkit::VideoView *arg1 = 0 ;
82457   Dali::Toolkit::VideoView *result = 0 ;
82458
82459   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82460   if (!arg1) {
82461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82462     return 0;
82463   }
82464   {
82465     try {
82466       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82467     } catch (std::out_of_range& e) {
82468       {
82469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82470       };
82471     } catch (std::exception& e) {
82472       {
82473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82474       };
82475     } catch (...) {
82476       {
82477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82478       };
82479     }
82480   }
82481   jresult = (void *)result;
82482   return jresult;
82483 }
82484
82485
82486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82487   void * jresult ;
82488   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82489   Dali::Toolkit::VideoView *arg2 = 0 ;
82490   Dali::Toolkit::VideoView *result = 0 ;
82491
82492   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82493   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82494   if (!arg2) {
82495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82496     return 0;
82497   }
82498   {
82499     try {
82500       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82508       };
82509     } catch (...) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82512       };
82513     }
82514   }
82515   jresult = (void *)result;
82516   return jresult;
82517 }
82518
82519
82520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82521   void * jresult ;
82522   Dali::BaseHandle arg1 ;
82523   Dali::BaseHandle *argp1 ;
82524   Dali::Toolkit::VideoView result;
82525
82526   argp1 = (Dali::BaseHandle *)jarg1;
82527   if (!argp1) {
82528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82529     return 0;
82530   }
82531   arg1 = *argp1;
82532   {
82533     try {
82534       result = Dali::Toolkit::VideoView::DownCast(arg1);
82535     } catch (std::out_of_range& e) {
82536       {
82537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82538       };
82539     } catch (std::exception& e) {
82540       {
82541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82542       };
82543     } catch (...) {
82544       {
82545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82546       };
82547     }
82548   }
82549   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82555   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82556
82557   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82558   {
82559     try {
82560       (arg1)->Play();
82561     } catch (std::out_of_range& e) {
82562       {
82563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82564       };
82565     } catch (std::exception& e) {
82566       {
82567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82568       };
82569     } catch (...) {
82570       {
82571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82572       };
82573     }
82574   }
82575 }
82576
82577
82578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82579   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82580
82581   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82582   {
82583     try {
82584       (arg1)->Pause();
82585     } catch (std::out_of_range& e) {
82586       {
82587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82588       };
82589     } catch (std::exception& e) {
82590       {
82591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82592       };
82593     } catch (...) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82596       };
82597     }
82598   }
82599 }
82600
82601
82602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82603   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82604
82605   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82606   {
82607     try {
82608       (arg1)->Stop();
82609     } catch (std::out_of_range& e) {
82610       {
82611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82612       };
82613     } catch (std::exception& e) {
82614       {
82615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82616       };
82617     } catch (...) {
82618       {
82619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82620       };
82621     }
82622   }
82623 }
82624
82625
82626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82627   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82628   int arg2 ;
82629
82630   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82631   arg2 = (int)jarg2;
82632   {
82633     try {
82634       (arg1)->Forward(arg2);
82635     } catch (std::out_of_range& e) {
82636       {
82637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82638       };
82639     } catch (std::exception& e) {
82640       {
82641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (...) {
82644       {
82645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82646       };
82647     }
82648   }
82649 }
82650
82651
82652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82653   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82654   int arg2 ;
82655
82656   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82657   arg2 = (int)jarg2;
82658   {
82659     try {
82660       (arg1)->Backward(arg2);
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82668       };
82669     } catch (...) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82672       };
82673     }
82674   }
82675 }
82676
82677
82678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82679   void * jresult ;
82680   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82681   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82682
82683   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82684   {
82685     try {
82686       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82698       };
82699     }
82700   }
82701   jresult = (void *)result;
82702   return jresult;
82703 }
82704
82705
82706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82707   int jresult ;
82708   int result;
82709
82710   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82711   jresult = (int)result;
82712   return jresult;
82713 }
82714
82715
82716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82717   int jresult ;
82718   int result;
82719
82720   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82721   jresult = (int)result;
82722   return jresult;
82723 }
82724
82725
82726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82727   int jresult ;
82728   int result;
82729
82730   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82731   jresult = (int)result;
82732   return jresult;
82733 }
82734
82735
82736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82737   int jresult ;
82738   int result;
82739
82740   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82741   jresult = (int)result;
82742   return jresult;
82743 }
82744
82745
82746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82747   int jresult ;
82748   int result;
82749
82750   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82751   jresult = (int)result;
82752   return jresult;
82753 }
82754
82755
82756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82757   int jresult ;
82758   int result;
82759
82760   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82761   jresult = (int)result;
82762   return jresult;
82763 }
82764
82765
82766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82767   int jresult ;
82768   int result;
82769
82770   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82771   jresult = (int)result;
82772   return jresult;
82773 }
82774
82775
82776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82777   int jresult ;
82778   int result;
82779
82780   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82781   jresult = (int)result;
82782   return jresult;
82783 }
82784
82785
82786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82787   int jresult ;
82788   int result;
82789
82790   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82791   jresult = (int)result;
82792   return jresult;
82793 }
82794
82795
82796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82797   int jresult ;
82798   int result;
82799
82800   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82801   jresult = (int)result;
82802   return jresult;
82803 }
82804
82805
82806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82807   int jresult ;
82808   int result;
82809
82810   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82811   jresult = (int)result;
82812   return jresult;
82813 }
82814
82815
82816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82817   int jresult ;
82818   int result;
82819
82820   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82821   jresult = (int)result;
82822   return jresult;
82823 }
82824
82825
82826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82827   int jresult ;
82828   int result;
82829
82830   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82831   jresult = (int)result;
82832   return jresult;
82833 }
82834
82835
82836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82837   int jresult ;
82838   int result;
82839
82840   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82841   jresult = (int)result;
82842   return jresult;
82843 }
82844
82845
82846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82847   int jresult ;
82848   int result;
82849
82850   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82851   jresult = (int)result;
82852   return jresult;
82853 }
82854
82855
82856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82857   int jresult ;
82858   int result;
82859
82860   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82861   jresult = (int)result;
82862   return jresult;
82863 }
82864
82865
82866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82867   int jresult ;
82868   int result;
82869
82870   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82871   jresult = (int)result;
82872   return jresult;
82873 }
82874
82875
82876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82877   int jresult ;
82878   int result;
82879
82880   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82881   jresult = (int)result;
82882   return jresult;
82883 }
82884
82885
82886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82887   int jresult ;
82888   int result;
82889
82890   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82891   jresult = (int)result;
82892   return jresult;
82893 }
82894
82895
82896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82897   int jresult ;
82898   int result;
82899
82900   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82901   jresult = (int)result;
82902   return jresult;
82903 }
82904
82905
82906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82907   int jresult ;
82908   int result;
82909
82910   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82911   jresult = (int)result;
82912   return jresult;
82913 }
82914
82915
82916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82917   void * jresult ;
82918   Dali::Toolkit::Popup::Property *result = 0 ;
82919
82920   {
82921     try {
82922       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82923     } catch (std::out_of_range& e) {
82924       {
82925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82926       };
82927     } catch (std::exception& e) {
82928       {
82929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82930       };
82931     } catch (...) {
82932       {
82933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82934       };
82935     }
82936   }
82937   jresult = (void *)result;
82938   return jresult;
82939 }
82940
82941
82942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82943   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82944
82945   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82946   {
82947     try {
82948       delete arg1;
82949     } catch (std::out_of_range& e) {
82950       {
82951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82952       };
82953     } catch (std::exception& e) {
82954       {
82955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82956       };
82957     } catch (...) {
82958       {
82959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82960       };
82961     }
82962   }
82963 }
82964
82965
82966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82967   void * jresult ;
82968   Dali::Toolkit::Popup *result = 0 ;
82969
82970   {
82971     try {
82972       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82973     } catch (std::out_of_range& e) {
82974       {
82975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (std::exception& e) {
82978       {
82979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82980       };
82981     } catch (...) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82984       };
82985     }
82986   }
82987   jresult = (void *)result;
82988   return jresult;
82989 }
82990
82991
82992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82993   void * jresult ;
82994   Dali::Toolkit::Popup result;
82995
82996   {
82997     try {
82998       result = Dali::Toolkit::Popup::New();
82999     } catch (std::out_of_range& e) {
83000       {
83001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83002       };
83003     } catch (std::exception& e) {
83004       {
83005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83006       };
83007     } catch (...) {
83008       {
83009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83010       };
83011     }
83012   }
83013   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83014   return jresult;
83015 }
83016
83017
83018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
83019   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83020
83021   arg1 = (Dali::Toolkit::Popup *)jarg1;
83022   {
83023     try {
83024       delete arg1;
83025     } catch (std::out_of_range& e) {
83026       {
83027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83028       };
83029     } catch (std::exception& e) {
83030       {
83031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83032       };
83033     } catch (...) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83036       };
83037     }
83038   }
83039 }
83040
83041
83042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83043   void * jresult ;
83044   Dali::Toolkit::Popup *arg1 = 0 ;
83045   Dali::Toolkit::Popup *result = 0 ;
83046
83047   arg1 = (Dali::Toolkit::Popup *)jarg1;
83048   if (!arg1) {
83049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83050     return 0;
83051   }
83052   {
83053     try {
83054       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83055     } catch (std::out_of_range& e) {
83056       {
83057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83058       };
83059     } catch (std::exception& e) {
83060       {
83061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (...) {
83064       {
83065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83066       };
83067     }
83068   }
83069   jresult = (void *)result;
83070   return jresult;
83071 }
83072
83073
83074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83075   void * jresult ;
83076   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83077   Dali::Toolkit::Popup *arg2 = 0 ;
83078   Dali::Toolkit::Popup *result = 0 ;
83079
83080   arg1 = (Dali::Toolkit::Popup *)jarg1;
83081   arg2 = (Dali::Toolkit::Popup *)jarg2;
83082   if (!arg2) {
83083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83084     return 0;
83085   }
83086   {
83087     try {
83088       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83089     } catch (std::out_of_range& e) {
83090       {
83091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83092       };
83093     } catch (std::exception& e) {
83094       {
83095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (...) {
83098       {
83099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83100       };
83101     }
83102   }
83103   jresult = (void *)result;
83104   return jresult;
83105 }
83106
83107
83108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83109   void * jresult ;
83110   Dali::BaseHandle arg1 ;
83111   Dali::BaseHandle *argp1 ;
83112   Dali::Toolkit::Popup result;
83113
83114   argp1 = (Dali::BaseHandle *)jarg1;
83115   if (!argp1) {
83116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83117     return 0;
83118   }
83119   arg1 = *argp1;
83120   {
83121     try {
83122       result = Dali::Toolkit::Popup::DownCast(arg1);
83123     } catch (std::out_of_range& e) {
83124       {
83125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83126       };
83127     } catch (std::exception& e) {
83128       {
83129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83130       };
83131     } catch (...) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83134       };
83135     }
83136   }
83137   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83138   return jresult;
83139 }
83140
83141
83142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83143   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83144   Dali::Actor arg2 ;
83145   Dali::Actor *argp2 ;
83146
83147   arg1 = (Dali::Toolkit::Popup *)jarg1;
83148   argp2 = (Dali::Actor *)jarg2;
83149   if (!argp2) {
83150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83151     return ;
83152   }
83153   arg2 = *argp2;
83154   {
83155     try {
83156       (arg1)->SetTitle(arg2);
83157     } catch (std::out_of_range& e) {
83158       {
83159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83160       };
83161     } catch (std::exception& e) {
83162       {
83163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83168       };
83169     }
83170   }
83171 }
83172
83173
83174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83175   void * jresult ;
83176   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83177   Dali::Actor result;
83178
83179   arg1 = (Dali::Toolkit::Popup *)jarg1;
83180   {
83181     try {
83182       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83183     } catch (std::out_of_range& e) {
83184       {
83185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83186       };
83187     } catch (std::exception& e) {
83188       {
83189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83190       };
83191     } catch (...) {
83192       {
83193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83194       };
83195     }
83196   }
83197   jresult = new Dali::Actor((const Dali::Actor &)result);
83198   return jresult;
83199 }
83200
83201
83202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83203   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83204   Dali::Actor arg2 ;
83205   Dali::Actor *argp2 ;
83206
83207   arg1 = (Dali::Toolkit::Popup *)jarg1;
83208   argp2 = (Dali::Actor *)jarg2;
83209   if (!argp2) {
83210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83211     return ;
83212   }
83213   arg2 = *argp2;
83214   {
83215     try {
83216       (arg1)->SetContent(arg2);
83217     } catch (std::out_of_range& e) {
83218       {
83219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83220       };
83221     } catch (std::exception& e) {
83222       {
83223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83224       };
83225     } catch (...) {
83226       {
83227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83228       };
83229     }
83230   }
83231 }
83232
83233
83234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83235   void * jresult ;
83236   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83237   Dali::Actor result;
83238
83239   arg1 = (Dali::Toolkit::Popup *)jarg1;
83240   {
83241     try {
83242       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83243     } catch (std::out_of_range& e) {
83244       {
83245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (std::exception& e) {
83248       {
83249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83254       };
83255     }
83256   }
83257   jresult = new Dali::Actor((const Dali::Actor &)result);
83258   return jresult;
83259 }
83260
83261
83262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83263   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83264   Dali::Actor arg2 ;
83265   Dali::Actor *argp2 ;
83266
83267   arg1 = (Dali::Toolkit::Popup *)jarg1;
83268   argp2 = (Dali::Actor *)jarg2;
83269   if (!argp2) {
83270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83271     return ;
83272   }
83273   arg2 = *argp2;
83274   {
83275     try {
83276       (arg1)->SetFooter(arg2);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83284       };
83285     } catch (...) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83288       };
83289     }
83290   }
83291 }
83292
83293
83294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83295   void * jresult ;
83296   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83297   Dali::Actor result;
83298
83299   arg1 = (Dali::Toolkit::Popup *)jarg1;
83300   {
83301     try {
83302       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (...) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83314       };
83315     }
83316   }
83317   jresult = new Dali::Actor((const Dali::Actor &)result);
83318   return jresult;
83319 }
83320
83321
83322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83323   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83324   Dali::Toolkit::Popup::DisplayState arg2 ;
83325
83326   arg1 = (Dali::Toolkit::Popup *)jarg1;
83327   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83328   {
83329     try {
83330       (arg1)->SetDisplayState(arg2);
83331     } catch (std::out_of_range& e) {
83332       {
83333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83334       };
83335     } catch (std::exception& e) {
83336       {
83337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83338       };
83339     } catch (...) {
83340       {
83341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83342       };
83343     }
83344   }
83345 }
83346
83347
83348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83349   int jresult ;
83350   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83351   Dali::Toolkit::Popup::DisplayState result;
83352
83353   arg1 = (Dali::Toolkit::Popup *)jarg1;
83354   {
83355     try {
83356       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83357     } catch (std::out_of_range& e) {
83358       {
83359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83360       };
83361     } catch (std::exception& e) {
83362       {
83363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (...) {
83366       {
83367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83368       };
83369     }
83370   }
83371   jresult = (int)result;
83372   return jresult;
83373 }
83374
83375
83376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83377   void * jresult ;
83378   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83379   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83380
83381   arg1 = (Dali::Toolkit::Popup *)jarg1;
83382   {
83383     try {
83384       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83385     } catch (std::out_of_range& e) {
83386       {
83387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (std::exception& e) {
83390       {
83391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83392       };
83393     } catch (...) {
83394       {
83395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83396       };
83397     }
83398   }
83399   jresult = (void *)result;
83400   return jresult;
83401 }
83402
83403
83404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83405   void * jresult ;
83406   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83407   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83408
83409   arg1 = (Dali::Toolkit::Popup *)jarg1;
83410   {
83411     try {
83412       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83413     } catch (std::out_of_range& e) {
83414       {
83415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (std::exception& e) {
83418       {
83419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (...) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83424       };
83425     }
83426   }
83427   jresult = (void *)result;
83428   return jresult;
83429 }
83430
83431
83432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83433   void * jresult ;
83434   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83435   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83436
83437   arg1 = (Dali::Toolkit::Popup *)jarg1;
83438   {
83439     try {
83440       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (...) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83452       };
83453     }
83454   }
83455   jresult = (void *)result;
83456   return jresult;
83457 }
83458
83459
83460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83461   void * jresult ;
83462   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83463   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83464
83465   arg1 = (Dali::Toolkit::Popup *)jarg1;
83466   {
83467     try {
83468       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83469     } catch (std::out_of_range& e) {
83470       {
83471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83472       };
83473     } catch (std::exception& e) {
83474       {
83475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83476       };
83477     } catch (...) {
83478       {
83479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83480       };
83481     }
83482   }
83483   jresult = (void *)result;
83484   return jresult;
83485 }
83486
83487
83488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83489   void * jresult ;
83490   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83491   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83492
83493   arg1 = (Dali::Toolkit::Popup *)jarg1;
83494   {
83495     try {
83496       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83497     } catch (std::out_of_range& e) {
83498       {
83499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83500       };
83501     } catch (std::exception& e) {
83502       {
83503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83504       };
83505     } catch (...) {
83506       {
83507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83508       };
83509     }
83510   }
83511   jresult = (void *)result;
83512   return jresult;
83513 }
83514
83515
83516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83517   int jresult ;
83518   int result;
83519
83520   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83521   jresult = (int)result;
83522   return jresult;
83523 }
83524
83525
83526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83527   int jresult ;
83528   int result;
83529
83530   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83531   jresult = (int)result;
83532   return jresult;
83533 }
83534
83535
83536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83537   int jresult ;
83538   int result;
83539
83540   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83541   jresult = (int)result;
83542   return jresult;
83543 }
83544
83545
83546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83547   int jresult ;
83548   int result;
83549
83550   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83551   jresult = (int)result;
83552   return jresult;
83553 }
83554
83555
83556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83557   int jresult ;
83558   int result;
83559
83560   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83561   jresult = (int)result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83567   int jresult ;
83568   int result;
83569
83570   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83571   jresult = (int)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83577   int jresult ;
83578   int result;
83579
83580   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83581   jresult = (int)result;
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83587   int jresult ;
83588   int result;
83589
83590   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83591   jresult = (int)result;
83592   return jresult;
83593 }
83594
83595
83596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83597   int jresult ;
83598   int result;
83599
83600   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83601   jresult = (int)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83607   void * jresult ;
83608   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83609
83610   {
83611     try {
83612       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83613     } catch (std::out_of_range& e) {
83614       {
83615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83616       };
83617     } catch (std::exception& e) {
83618       {
83619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83620       };
83621     } catch (...) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83624       };
83625     }
83626   }
83627   jresult = (void *)result;
83628   return jresult;
83629 }
83630
83631
83632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83633   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83634
83635   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83636   {
83637     try {
83638       delete arg1;
83639     } catch (std::out_of_range& e) {
83640       {
83641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83642       };
83643     } catch (std::exception& e) {
83644       {
83645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83646       };
83647     } catch (...) {
83648       {
83649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83650       };
83651     }
83652   }
83653 }
83654
83655
83656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83657   void * jresult ;
83658   Dali::Toolkit::ProgressBar result;
83659
83660   {
83661     try {
83662       result = Dali::Toolkit::ProgressBar::New();
83663     } catch (std::out_of_range& e) {
83664       {
83665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83666       };
83667     } catch (std::exception& e) {
83668       {
83669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83670       };
83671     } catch (...) {
83672       {
83673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83674       };
83675     }
83676   }
83677   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83678   return jresult;
83679 }
83680
83681
83682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83683   void * jresult ;
83684   Dali::Toolkit::ProgressBar *result = 0 ;
83685
83686   {
83687     try {
83688       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83689     } catch (std::out_of_range& e) {
83690       {
83691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83692       };
83693     } catch (std::exception& e) {
83694       {
83695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83696       };
83697     } catch (...) {
83698       {
83699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83700       };
83701     }
83702   }
83703   jresult = (void *)result;
83704   return jresult;
83705 }
83706
83707
83708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83709   void * jresult ;
83710   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83711   Dali::Toolkit::ProgressBar *result = 0 ;
83712
83713   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83714   if (!arg1) {
83715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83716     return 0;
83717   }
83718   {
83719     try {
83720       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83721     } catch (std::out_of_range& e) {
83722       {
83723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83724       };
83725     } catch (std::exception& e) {
83726       {
83727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83728       };
83729     } catch (...) {
83730       {
83731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83732       };
83733     }
83734   }
83735   jresult = (void *)result;
83736   return jresult;
83737 }
83738
83739
83740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83741   void * jresult ;
83742   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83743   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83744   Dali::Toolkit::ProgressBar *result = 0 ;
83745
83746   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83747   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83748   if (!arg2) {
83749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83750     return 0;
83751   }
83752   {
83753     try {
83754       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83755     } catch (std::out_of_range& e) {
83756       {
83757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83758       };
83759     } catch (std::exception& e) {
83760       {
83761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83762       };
83763     } catch (...) {
83764       {
83765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83766       };
83767     }
83768   }
83769   jresult = (void *)result;
83770   return jresult;
83771 }
83772
83773
83774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83775   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83776
83777   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83778   {
83779     try {
83780       delete arg1;
83781     } catch (std::out_of_range& e) {
83782       {
83783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83784       };
83785     } catch (std::exception& e) {
83786       {
83787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83788       };
83789     } catch (...) {
83790       {
83791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83792       };
83793     }
83794   }
83795 }
83796
83797
83798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83799   void * jresult ;
83800   Dali::BaseHandle arg1 ;
83801   Dali::BaseHandle *argp1 ;
83802   Dali::Toolkit::ProgressBar result;
83803
83804   argp1 = (Dali::BaseHandle *)jarg1;
83805   if (!argp1) {
83806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83807     return 0;
83808   }
83809   arg1 = *argp1;
83810   {
83811     try {
83812       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83813     } catch (std::out_of_range& e) {
83814       {
83815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83816       };
83817     } catch (std::exception& e) {
83818       {
83819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83820       };
83821     } catch (...) {
83822       {
83823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83824       };
83825     }
83826   }
83827   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83828   return jresult;
83829 }
83830
83831
83832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83833   void * jresult ;
83834   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83835   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83836
83837   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83838   {
83839     try {
83840       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83841     } catch (std::out_of_range& e) {
83842       {
83843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83844       };
83845     } catch (std::exception& e) {
83846       {
83847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (...) {
83850       {
83851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83852       };
83853     }
83854   }
83855   jresult = (void *)result;
83856   return jresult;
83857 }
83858
83859
83860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83861   void * jresult ;
83862   Dali::Toolkit::GaussianBlurView *result = 0 ;
83863
83864   {
83865     try {
83866       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83867     } catch (std::out_of_range& e) {
83868       {
83869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83870       };
83871     } catch (std::exception& e) {
83872       {
83873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83878       };
83879     }
83880   }
83881   jresult = (void *)result;
83882   return jresult;
83883 }
83884
83885
83886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83887   void * jresult ;
83888   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83889   Dali::Toolkit::GaussianBlurView *result = 0 ;
83890
83891   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83892   if (!arg1) {
83893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83894     return 0;
83895   }
83896   {
83897     try {
83898       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83899     } catch (std::out_of_range& e) {
83900       {
83901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83902       };
83903     } catch (std::exception& e) {
83904       {
83905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83906       };
83907     } catch (...) {
83908       {
83909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83910       };
83911     }
83912   }
83913   jresult = (void *)result;
83914   return jresult;
83915 }
83916
83917
83918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83919   void * jresult ;
83920   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83921   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83922   Dali::Toolkit::GaussianBlurView *result = 0 ;
83923
83924   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83925   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83926   if (!arg2) {
83927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83928     return 0;
83929   }
83930   {
83931     try {
83932       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83933     } catch (std::out_of_range& e) {
83934       {
83935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83936       };
83937     } catch (std::exception& e) {
83938       {
83939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (...) {
83942       {
83943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83944       };
83945     }
83946   }
83947   jresult = (void *)result;
83948   return jresult;
83949 }
83950
83951
83952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83953   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83954
83955   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83956   {
83957     try {
83958       delete arg1;
83959     } catch (std::out_of_range& e) {
83960       {
83961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83962       };
83963     } catch (std::exception& e) {
83964       {
83965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83966       };
83967     } catch (...) {
83968       {
83969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83970       };
83971     }
83972   }
83973 }
83974
83975
83976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83977   void * jresult ;
83978   Dali::BaseHandle arg1 ;
83979   Dali::BaseHandle *argp1 ;
83980   Dali::Toolkit::GaussianBlurView result;
83981
83982   argp1 = (Dali::BaseHandle *)jarg1;
83983   if (!argp1) {
83984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83985     return 0;
83986   }
83987   arg1 = *argp1;
83988   {
83989     try {
83990       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83991     } catch (std::out_of_range& e) {
83992       {
83993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83994       };
83995     } catch (std::exception& e) {
83996       {
83997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83998       };
83999     } catch (...) {
84000       {
84001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84002       };
84003     }
84004   }
84005   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84011   void * jresult ;
84012   Dali::Toolkit::GaussianBlurView result;
84013
84014   {
84015     try {
84016       result = Dali::Toolkit::GaussianBlurView::New();
84017     } catch (std::out_of_range& e) {
84018       {
84019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84020       };
84021     } catch (std::exception& e) {
84022       {
84023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84024       };
84025     } catch (...) {
84026       {
84027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84028       };
84029     }
84030   }
84031   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84032   return jresult;
84033 }
84034
84035
84036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84037   void * jresult ;
84038   unsigned int arg1 ;
84039   float arg2 ;
84040   Dali::Pixel::Format arg3 ;
84041   float arg4 ;
84042   float arg5 ;
84043   bool arg6 ;
84044   Dali::Toolkit::GaussianBlurView result;
84045
84046   arg1 = (unsigned int)jarg1;
84047   arg2 = (float)jarg2;
84048   arg3 = (Dali::Pixel::Format)jarg3;
84049   arg4 = (float)jarg4;
84050   arg5 = (float)jarg5;
84051   arg6 = jarg6 ? true : false;
84052   {
84053     try {
84054       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84055     } catch (std::out_of_range& e) {
84056       {
84057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84058       };
84059     } catch (std::exception& e) {
84060       {
84061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84066       };
84067     }
84068   }
84069   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84070   return jresult;
84071 }
84072
84073
84074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84075   void * jresult ;
84076   unsigned int arg1 ;
84077   float arg2 ;
84078   Dali::Pixel::Format arg3 ;
84079   float arg4 ;
84080   float arg5 ;
84081   Dali::Toolkit::GaussianBlurView result;
84082
84083   arg1 = (unsigned int)jarg1;
84084   arg2 = (float)jarg2;
84085   arg3 = (Dali::Pixel::Format)jarg3;
84086   arg4 = (float)jarg4;
84087   arg5 = (float)jarg5;
84088   {
84089     try {
84090       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84102       };
84103     }
84104   }
84105   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84111   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84112   Dali::Actor arg2 ;
84113   Dali::Actor *argp2 ;
84114
84115   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84116   argp2 = (Dali::Actor *)jarg2;
84117   if (!argp2) {
84118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84119     return ;
84120   }
84121   arg2 = *argp2;
84122   {
84123     try {
84124       (arg1)->Add(arg2);
84125     } catch (std::out_of_range& e) {
84126       {
84127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84128       };
84129     } catch (std::exception& e) {
84130       {
84131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84132       };
84133     } catch (...) {
84134       {
84135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84136       };
84137     }
84138   }
84139 }
84140
84141
84142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84143   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84144   Dali::Actor arg2 ;
84145   Dali::Actor *argp2 ;
84146
84147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84148   argp2 = (Dali::Actor *)jarg2;
84149   if (!argp2) {
84150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84151     return ;
84152   }
84153   arg2 = *argp2;
84154   {
84155     try {
84156       (arg1)->Remove(arg2);
84157     } catch (std::out_of_range& e) {
84158       {
84159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84160       };
84161     } catch (std::exception& e) {
84162       {
84163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84164       };
84165     } catch (...) {
84166       {
84167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84168       };
84169     }
84170   }
84171 }
84172
84173
84174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84175   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84176
84177   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84178   {
84179     try {
84180       (arg1)->Activate();
84181     } catch (std::out_of_range& e) {
84182       {
84183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84184       };
84185     } catch (std::exception& e) {
84186       {
84187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (...) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84192       };
84193     }
84194   }
84195 }
84196
84197
84198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84199   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84200
84201   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84202   {
84203     try {
84204       (arg1)->ActivateOnce();
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84216       };
84217     }
84218   }
84219 }
84220
84221
84222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84223   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84224
84225   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84226   {
84227     try {
84228       (arg1)->Deactivate();
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84240       };
84241     }
84242   }
84243 }
84244
84245
84246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84247   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84248   Dali::Image arg2 ;
84249   Dali::FrameBufferImage arg3 ;
84250   Dali::Image *argp2 ;
84251   Dali::FrameBufferImage *argp3 ;
84252
84253   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84254   argp2 = (Dali::Image *)jarg2;
84255   if (!argp2) {
84256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84257     return ;
84258   }
84259   arg2 = *argp2;
84260   argp3 = (Dali::FrameBufferImage *)jarg3;
84261   if (!argp3) {
84262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84263     return ;
84264   }
84265   arg3 = *argp3;
84266   {
84267     try {
84268       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84269     } catch (std::out_of_range& e) {
84270       {
84271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84272       };
84273     } catch (std::exception& e) {
84274       {
84275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84276       };
84277     } catch (...) {
84278       {
84279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84280       };
84281     }
84282   }
84283 }
84284
84285
84286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84287   int jresult ;
84288   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84289   Dali::Property::Index result;
84290
84291   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84292   {
84293     try {
84294       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84295     } catch (std::out_of_range& e) {
84296       {
84297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (std::exception& e) {
84300       {
84301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (...) {
84304       {
84305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84306       };
84307     }
84308   }
84309   jresult = result;
84310   return jresult;
84311 }
84312
84313
84314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84315   void * jresult ;
84316   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84317   Dali::FrameBufferImage result;
84318
84319   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84320   {
84321     try {
84322       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84323     } catch (std::out_of_range& e) {
84324       {
84325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84326       };
84327     } catch (std::exception& e) {
84328       {
84329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (...) {
84332       {
84333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84334       };
84335     }
84336   }
84337   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84343   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84344   Dali::Vector4 *arg2 = 0 ;
84345
84346   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84347   arg2 = (Dali::Vector4 *)jarg2;
84348   if (!arg2) {
84349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84350     return ;
84351   }
84352   {
84353     try {
84354       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84355     } catch (std::out_of_range& e) {
84356       {
84357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84358       };
84359     } catch (std::exception& e) {
84360       {
84361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84362       };
84363     } catch (...) {
84364       {
84365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84366       };
84367     }
84368   }
84369 }
84370
84371
84372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84373   void * jresult ;
84374   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84375   Dali::Vector4 result;
84376
84377   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84378   {
84379     try {
84380       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84381     } catch (std::out_of_range& e) {
84382       {
84383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84384       };
84385     } catch (std::exception& e) {
84386       {
84387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (...) {
84390       {
84391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84392       };
84393     }
84394   }
84395   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84396   return jresult;
84397 }
84398
84399
84400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84401   void * jresult ;
84402   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84403   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84404
84405   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84406   {
84407     try {
84408       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84409     } catch (std::out_of_range& e) {
84410       {
84411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84412       };
84413     } catch (std::exception& e) {
84414       {
84415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84416       };
84417     } catch (...) {
84418       {
84419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84420       };
84421     }
84422   }
84423   jresult = (void *)result;
84424   return jresult;
84425 }
84426
84427
84428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84429   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84430
84431   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84432   {
84433     try {
84434       delete arg1;
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84446       };
84447     }
84448   }
84449 }
84450
84451
84452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84453   unsigned int jresult ;
84454   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84455   unsigned int result;
84456
84457   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84458   {
84459     try {
84460       result = (unsigned int)(arg1)->GetNumberOfPages();
84461     } catch (std::out_of_range& e) {
84462       {
84463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84464       };
84465     } catch (std::exception& e) {
84466       {
84467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84468       };
84469     } catch (...) {
84470       {
84471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84472       };
84473     }
84474   }
84475   jresult = result;
84476   return jresult;
84477 }
84478
84479
84480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84481   void * jresult ;
84482   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84483   unsigned int arg2 ;
84484   Dali::Texture result;
84485
84486   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84487   arg2 = (unsigned int)jarg2;
84488   {
84489     try {
84490       result = (arg1)->NewPage(arg2);
84491     } catch (std::out_of_range& e) {
84492       {
84493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (std::exception& e) {
84496       {
84497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (...) {
84500       {
84501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84502       };
84503     }
84504   }
84505   jresult = new Dali::Texture((const Dali::Texture &)result);
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84511   int jresult ;
84512   int result;
84513
84514   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84515   jresult = (int)result;
84516   return jresult;
84517 }
84518
84519
84520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84521   int jresult ;
84522   int result;
84523
84524   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84525   jresult = (int)result;
84526   return jresult;
84527 }
84528
84529
84530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84531   int jresult ;
84532   int result;
84533
84534   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84535   jresult = (int)result;
84536   return jresult;
84537 }
84538
84539
84540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84541   void * jresult ;
84542   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84543
84544   {
84545     try {
84546       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84547     } catch (std::out_of_range& e) {
84548       {
84549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (std::exception& e) {
84552       {
84553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561   jresult = (void *)result;
84562   return jresult;
84563 }
84564
84565
84566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84567   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84568
84569   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84570   {
84571     try {
84572       delete arg1;
84573     } catch (std::out_of_range& e) {
84574       {
84575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84576       };
84577     } catch (std::exception& e) {
84578       {
84579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84584       };
84585     }
84586   }
84587 }
84588
84589
84590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84591   void * jresult ;
84592   Dali::Toolkit::PageTurnView *result = 0 ;
84593
84594   {
84595     try {
84596       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84604       };
84605     } catch (...) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84608       };
84609     }
84610   }
84611   jresult = (void *)result;
84612   return jresult;
84613 }
84614
84615
84616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84617   void * jresult ;
84618   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84619   Dali::Toolkit::PageTurnView *result = 0 ;
84620
84621   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84622   if (!arg1) {
84623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84624     return 0;
84625   }
84626   {
84627     try {
84628       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84629     } catch (std::out_of_range& e) {
84630       {
84631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84632       };
84633     } catch (std::exception& e) {
84634       {
84635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84636       };
84637     } catch (...) {
84638       {
84639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84640       };
84641     }
84642   }
84643   jresult = (void *)result;
84644   return jresult;
84645 }
84646
84647
84648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84649   void * jresult ;
84650   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84651   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84652   Dali::Toolkit::PageTurnView *result = 0 ;
84653
84654   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84655   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84656   if (!arg2) {
84657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84658     return 0;
84659   }
84660   {
84661     try {
84662       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84663     } catch (std::out_of_range& e) {
84664       {
84665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (std::exception& e) {
84668       {
84669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (...) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84674       };
84675     }
84676   }
84677   jresult = (void *)result;
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84683   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84684
84685   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84686   {
84687     try {
84688       delete arg1;
84689     } catch (std::out_of_range& e) {
84690       {
84691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84692       };
84693     } catch (std::exception& e) {
84694       {
84695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84696       };
84697     } catch (...) {
84698       {
84699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84700       };
84701     }
84702   }
84703 }
84704
84705
84706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84707   void * jresult ;
84708   Dali::BaseHandle arg1 ;
84709   Dali::BaseHandle *argp1 ;
84710   Dali::Toolkit::PageTurnView result;
84711
84712   argp1 = (Dali::BaseHandle *)jarg1;
84713   if (!argp1) {
84714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84715     return 0;
84716   }
84717   arg1 = *argp1;
84718   {
84719     try {
84720       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84721     } catch (std::out_of_range& e) {
84722       {
84723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (std::exception& e) {
84726       {
84727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84728       };
84729     } catch (...) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84732       };
84733     }
84734   }
84735   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84736   return jresult;
84737 }
84738
84739
84740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84741   void * jresult ;
84742   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84743   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84744
84745   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84746   {
84747     try {
84748       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84749     } catch (std::out_of_range& e) {
84750       {
84751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (std::exception& e) {
84754       {
84755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84756       };
84757     } catch (...) {
84758       {
84759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84760       };
84761     }
84762   }
84763   jresult = (void *)result;
84764   return jresult;
84765 }
84766
84767
84768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84769   void * jresult ;
84770   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84771   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84772
84773   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84774   {
84775     try {
84776       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84797   void * jresult ;
84798   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84799   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84800
84801   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84802   {
84803     try {
84804       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84805     } catch (std::out_of_range& e) {
84806       {
84807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (std::exception& e) {
84810       {
84811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84812       };
84813     } catch (...) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84816       };
84817     }
84818   }
84819   jresult = (void *)result;
84820   return jresult;
84821 }
84822
84823
84824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84825   void * jresult ;
84826   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84827   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84828
84829   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84830   {
84831     try {
84832       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84833     } catch (std::out_of_range& e) {
84834       {
84835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (std::exception& e) {
84838       {
84839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (...) {
84842       {
84843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84844       };
84845     }
84846   }
84847   jresult = (void *)result;
84848   return jresult;
84849 }
84850
84851
84852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84853   void * jresult ;
84854   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84855
84856   {
84857     try {
84858       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84859     } catch (std::out_of_range& e) {
84860       {
84861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84862       };
84863     } catch (std::exception& e) {
84864       {
84865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84866       };
84867     } catch (...) {
84868       {
84869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84870       };
84871     }
84872   }
84873   jresult = (void *)result;
84874   return jresult;
84875 }
84876
84877
84878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84879   void * jresult ;
84880   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84881   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84882
84883   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84884   if (!arg1) {
84885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84886     return 0;
84887   }
84888   {
84889     try {
84890       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84891     } catch (std::out_of_range& e) {
84892       {
84893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (std::exception& e) {
84896       {
84897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84898       };
84899     } catch (...) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84902       };
84903     }
84904   }
84905   jresult = (void *)result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84911   void * jresult ;
84912   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84913   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84914   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84915
84916   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84917   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84918   if (!arg2) {
84919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84920     return 0;
84921   }
84922   {
84923     try {
84924       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84925     } catch (std::out_of_range& e) {
84926       {
84927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84928       };
84929     } catch (std::exception& e) {
84930       {
84931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84932       };
84933     } catch (...) {
84934       {
84935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84936       };
84937     }
84938   }
84939   jresult = (void *)result;
84940   return jresult;
84941 }
84942
84943
84944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84945   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84946
84947   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84948   {
84949     try {
84950       delete arg1;
84951     } catch (std::out_of_range& e) {
84952       {
84953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84954       };
84955     } catch (std::exception& e) {
84956       {
84957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84962       };
84963     }
84964   }
84965 }
84966
84967
84968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84969   void * jresult ;
84970   Dali::Toolkit::PageFactory *arg1 = 0 ;
84971   Dali::Vector2 *arg2 = 0 ;
84972   Dali::Toolkit::PageTurnLandscapeView result;
84973
84974   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84975   if (!arg1) {
84976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84977     return 0;
84978   }
84979   arg2 = (Dali::Vector2 *)jarg2;
84980   if (!arg2) {
84981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84982     return 0;
84983   }
84984   {
84985     try {
84986       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84998       };
84999     }
85000   }
85001   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85002   return jresult;
85003 }
85004
85005
85006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85007   void * jresult ;
85008   Dali::BaseHandle arg1 ;
85009   Dali::BaseHandle *argp1 ;
85010   Dali::Toolkit::PageTurnLandscapeView result;
85011
85012   argp1 = (Dali::BaseHandle *)jarg1;
85013   if (!argp1) {
85014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85015     return 0;
85016   }
85017   arg1 = *argp1;
85018   {
85019     try {
85020       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85021     } catch (std::out_of_range& e) {
85022       {
85023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85024       };
85025     } catch (std::exception& e) {
85026       {
85027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85028       };
85029     } catch (...) {
85030       {
85031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85032       };
85033     }
85034   }
85035   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85036   return jresult;
85037 }
85038
85039
85040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85041   void * jresult ;
85042   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85043
85044   {
85045     try {
85046       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85047     } catch (std::out_of_range& e) {
85048       {
85049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85050       };
85051     } catch (std::exception& e) {
85052       {
85053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85054       };
85055     } catch (...) {
85056       {
85057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85058       };
85059     }
85060   }
85061   jresult = (void *)result;
85062   return jresult;
85063 }
85064
85065
85066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85067   void * jresult ;
85068   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85069   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85070
85071   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85072   if (!arg1) {
85073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85074     return 0;
85075   }
85076   {
85077     try {
85078       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85090       };
85091     }
85092   }
85093   jresult = (void *)result;
85094   return jresult;
85095 }
85096
85097
85098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85099   void * jresult ;
85100   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85101   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85102   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85103
85104   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85105   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85106   if (!arg2) {
85107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85108     return 0;
85109   }
85110   {
85111     try {
85112       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85113     } catch (std::out_of_range& e) {
85114       {
85115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85116       };
85117     } catch (std::exception& e) {
85118       {
85119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85120       };
85121     } catch (...) {
85122       {
85123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85124       };
85125     }
85126   }
85127   jresult = (void *)result;
85128   return jresult;
85129 }
85130
85131
85132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85133   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85134
85135   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85136   {
85137     try {
85138       delete arg1;
85139     } catch (std::out_of_range& e) {
85140       {
85141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85142       };
85143     } catch (std::exception& e) {
85144       {
85145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85146       };
85147     } catch (...) {
85148       {
85149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85150       };
85151     }
85152   }
85153 }
85154
85155
85156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85157   void * jresult ;
85158   Dali::Toolkit::PageFactory *arg1 = 0 ;
85159   Dali::Vector2 *arg2 = 0 ;
85160   Dali::Toolkit::PageTurnPortraitView result;
85161
85162   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85163   if (!arg1) {
85164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85165     return 0;
85166   }
85167   arg2 = (Dali::Vector2 *)jarg2;
85168   if (!arg2) {
85169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85170     return 0;
85171   }
85172   {
85173     try {
85174       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85175     } catch (std::out_of_range& e) {
85176       {
85177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (std::exception& e) {
85180       {
85181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85182       };
85183     } catch (...) {
85184       {
85185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85186       };
85187     }
85188   }
85189   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85190   return jresult;
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85195   void * jresult ;
85196   Dali::BaseHandle arg1 ;
85197   Dali::BaseHandle *argp1 ;
85198   Dali::Toolkit::PageTurnPortraitView result;
85199
85200   argp1 = (Dali::BaseHandle *)jarg1;
85201   if (!argp1) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85203     return 0;
85204   }
85205   arg1 = *argp1;
85206   {
85207     try {
85208       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85229   int jresult ;
85230   int result;
85231
85232   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85233   jresult = (int)result;
85234   return jresult;
85235 }
85236
85237
85238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85239   int jresult ;
85240   int result;
85241
85242   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85243   jresult = (int)result;
85244   return jresult;
85245 }
85246
85247
85248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85249   int jresult ;
85250   int result;
85251
85252   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85253   jresult = (int)result;
85254   return jresult;
85255 }
85256
85257
85258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85259   void * jresult ;
85260   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85261
85262   {
85263     try {
85264       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85265     } catch (std::out_of_range& e) {
85266       {
85267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85268       };
85269     } catch (std::exception& e) {
85270       {
85271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85272       };
85273     } catch (...) {
85274       {
85275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85276       };
85277     }
85278   }
85279   jresult = (void *)result;
85280   return jresult;
85281 }
85282
85283
85284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85285   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85286
85287   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85288   {
85289     try {
85290       delete arg1;
85291     } catch (std::out_of_range& e) {
85292       {
85293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85294       };
85295     } catch (std::exception& e) {
85296       {
85297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85298       };
85299     } catch (...) {
85300       {
85301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85302       };
85303     }
85304   }
85305 }
85306
85307
85308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85309   void * jresult ;
85310   Dali::Toolkit::ToggleButton *result = 0 ;
85311
85312   {
85313     try {
85314       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85315     } catch (std::out_of_range& e) {
85316       {
85317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85318       };
85319     } catch (std::exception& e) {
85320       {
85321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (...) {
85324       {
85325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85326       };
85327     }
85328   }
85329   jresult = (void *)result;
85330   return jresult;
85331 }
85332
85333
85334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85335   void * jresult ;
85336   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85337   Dali::Toolkit::ToggleButton *result = 0 ;
85338
85339   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85340   if (!arg1) {
85341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85342     return 0;
85343   }
85344   {
85345     try {
85346       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85347     } catch (std::out_of_range& e) {
85348       {
85349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85350       };
85351     } catch (std::exception& e) {
85352       {
85353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85354       };
85355     } catch (...) {
85356       {
85357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85358       };
85359     }
85360   }
85361   jresult = (void *)result;
85362   return jresult;
85363 }
85364
85365
85366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85367   void * jresult ;
85368   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85369   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85370   Dali::Toolkit::ToggleButton *result = 0 ;
85371
85372   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85373   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85374   if (!arg2) {
85375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85376     return 0;
85377   }
85378   {
85379     try {
85380       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85381     } catch (std::out_of_range& e) {
85382       {
85383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (std::exception& e) {
85386       {
85387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85392       };
85393     }
85394   }
85395   jresult = (void *)result;
85396   return jresult;
85397 }
85398
85399
85400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85401   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85402
85403   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85404   {
85405     try {
85406       delete arg1;
85407     } catch (std::out_of_range& e) {
85408       {
85409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85410       };
85411     } catch (std::exception& e) {
85412       {
85413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85414       };
85415     } catch (...) {
85416       {
85417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85418       };
85419     }
85420   }
85421 }
85422
85423
85424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85425   void * jresult ;
85426   Dali::Toolkit::ToggleButton result;
85427
85428   {
85429     try {
85430       result = Dali::Toolkit::ToggleButton::New();
85431     } catch (std::out_of_range& e) {
85432       {
85433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85434       };
85435     } catch (std::exception& e) {
85436       {
85437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85438       };
85439     } catch (...) {
85440       {
85441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85442       };
85443     }
85444   }
85445   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85446   return jresult;
85447 }
85448
85449
85450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85451   void * jresult ;
85452   Dali::BaseHandle arg1 ;
85453   Dali::BaseHandle *argp1 ;
85454   Dali::Toolkit::ToggleButton result;
85455
85456   argp1 = (Dali::BaseHandle *)jarg1;
85457   if (!argp1) {
85458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85459     return 0;
85460   }
85461   arg1 = *argp1;
85462   {
85463     try {
85464       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85465     } catch (std::out_of_range& e) {
85466       {
85467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85468       };
85469     } catch (std::exception& e) {
85470       {
85471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (...) {
85474       {
85475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85476       };
85477     }
85478   }
85479   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85480   return jresult;
85481 }
85482
85483
85484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85485   void * jresult ;
85486   Dali::Toolkit::Visual::Base *result = 0 ;
85487
85488   {
85489     try {
85490       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85491     } catch (std::out_of_range& e) {
85492       {
85493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (std::exception& e) {
85496       {
85497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505   jresult = (void *)result;
85506   return jresult;
85507 }
85508
85509
85510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85511   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85512
85513   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85514   {
85515     try {
85516       delete arg1;
85517     } catch (std::out_of_range& e) {
85518       {
85519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85520       };
85521     } catch (std::exception& e) {
85522       {
85523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85524       };
85525     } catch (...) {
85526       {
85527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85528       };
85529     }
85530   }
85531 }
85532
85533
85534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85535   void * jresult ;
85536   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85537   Dali::Toolkit::Visual::Base *result = 0 ;
85538
85539   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85540   if (!arg1) {
85541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85542     return 0;
85543   }
85544   {
85545     try {
85546       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85547     } catch (std::out_of_range& e) {
85548       {
85549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (std::exception& e) {
85552       {
85553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (...) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85558       };
85559     }
85560   }
85561   jresult = (void *)result;
85562   return jresult;
85563 }
85564
85565
85566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85567   void * jresult ;
85568   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85569   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85570   Dali::Toolkit::Visual::Base *result = 0 ;
85571
85572   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85573   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85574   if (!arg2) {
85575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85576     return 0;
85577   }
85578   {
85579     try {
85580       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85581     } catch (std::out_of_range& e) {
85582       {
85583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85584       };
85585     } catch (std::exception& e) {
85586       {
85587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85588       };
85589     } catch (...) {
85590       {
85591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85592       };
85593     }
85594   }
85595   jresult = (void *)result;
85596   return jresult;
85597 }
85598
85599
85600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85601   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85602   std::string *arg2 = 0 ;
85603
85604   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85605   if (!jarg2) {
85606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85607     return ;
85608   }
85609   std::string arg2_str(jarg2);
85610   arg2 = &arg2_str;
85611   {
85612     try {
85613       (arg1)->SetName((std::string const &)*arg2);
85614     } catch (std::out_of_range& e) {
85615       {
85616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85617       };
85618     } catch (std::exception& e) {
85619       {
85620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85621       };
85622     } catch (...) {
85623       {
85624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85625       };
85626     }
85627   }
85628
85629   //argout typemap for const std::string&
85630
85631 }
85632
85633
85634 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85635   char * jresult ;
85636   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85637   std::string *result = 0 ;
85638
85639   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85640   {
85641     try {
85642       result = (std::string *) &(arg1)->GetName();
85643     } catch (std::out_of_range& e) {
85644       {
85645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85646       };
85647     } catch (std::exception& e) {
85648       {
85649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85650       };
85651     } catch (...) {
85652       {
85653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85654       };
85655     }
85656   }
85657   jresult = SWIG_csharp_string_callback(result->c_str());
85658   return jresult;
85659 }
85660
85661
85662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85663   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85664   Dali::Property::Map *arg2 = 0 ;
85665   Dali::Size arg3 ;
85666   Dali::Size *argp3 ;
85667
85668   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85669   arg2 = (Dali::Property::Map *)jarg2;
85670   if (!arg2) {
85671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85672     return ;
85673   }
85674   argp3 = (Dali::Size *)jarg3;
85675   if (!argp3) {
85676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85677     return ;
85678   }
85679   arg3 = *argp3;
85680   {
85681     try {
85682       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85683     } catch (std::out_of_range& e) {
85684       {
85685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85686       };
85687     } catch (std::exception& e) {
85688       {
85689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85694       };
85695     }
85696   }
85697 }
85698
85699
85700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85701   float jresult ;
85702   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85703   float arg2 ;
85704   float result;
85705
85706   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85707   arg2 = (float)jarg2;
85708   {
85709     try {
85710       result = (float)(arg1)->GetHeightForWidth(arg2);
85711     } catch (std::out_of_range& e) {
85712       {
85713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85714       };
85715     } catch (std::exception& e) {
85716       {
85717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85718       };
85719     } catch (...) {
85720       {
85721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85722       };
85723     }
85724   }
85725   jresult = result;
85726   return jresult;
85727 }
85728
85729
85730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85731   float jresult ;
85732   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85733   float arg2 ;
85734   float result;
85735
85736   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85737   arg2 = (float)jarg2;
85738   {
85739     try {
85740       result = (float)(arg1)->GetWidthForHeight(arg2);
85741     } catch (std::out_of_range& e) {
85742       {
85743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85744       };
85745     } catch (std::exception& e) {
85746       {
85747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85748       };
85749     } catch (...) {
85750       {
85751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85752       };
85753     }
85754   }
85755   jresult = result;
85756   return jresult;
85757 }
85758
85759
85760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85761   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85762   Dali::Vector2 *arg2 = 0 ;
85763
85764   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85765   arg2 = (Dali::Vector2 *)jarg2;
85766   if (!arg2) {
85767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85768     return ;
85769   }
85770   {
85771     try {
85772       (arg1)->GetNaturalSize(*arg2);
85773     } catch (std::out_of_range& e) {
85774       {
85775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85776       };
85777     } catch (std::exception& e) {
85778       {
85779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85780       };
85781     } catch (...) {
85782       {
85783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85784       };
85785     }
85786   }
85787 }
85788
85789
85790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85791   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85792   float arg2 ;
85793
85794   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85795   arg2 = (int)jarg2;
85796   {
85797     try {
85798       (arg1)->SetDepthIndex(arg2);
85799     } catch (std::out_of_range& e) {
85800       {
85801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85802       };
85803     } catch (std::exception& e) {
85804       {
85805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85806       };
85807     } catch (...) {
85808       {
85809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85810       };
85811     }
85812   }
85813 }
85814
85815
85816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85817   int jresult ;
85818   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85819   int result;
85820
85821   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85822   {
85823     try {
85824       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85825     } catch (std::out_of_range& e) {
85826       {
85827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85828       };
85829     } catch (std::exception& e) {
85830       {
85831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85832       };
85833     } catch (...) {
85834       {
85835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85836       };
85837     }
85838   }
85839   jresult = result;
85840   return jresult;
85841 }
85842
85843
85844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85845   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85846   Dali::Property::Map *arg2 = 0 ;
85847
85848   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85849   arg2 = (Dali::Property::Map *)jarg2;
85850   if (!arg2) {
85851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85852     return ;
85853   }
85854   {
85855     try {
85856       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85857     } catch (std::out_of_range& e) {
85858       {
85859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85860       };
85861     } catch (std::exception& e) {
85862       {
85863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85864       };
85865     } catch (...) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85868       };
85869     }
85870   }
85871 }
85872
85873
85874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85875   void * jresult ;
85876   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85877   Dali::Toolkit::Visual::Base *result = 0 ;
85878
85879   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85880   {
85881     try {
85882       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (...) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85894       };
85895     }
85896   }
85897   jresult = (void *)result;
85898   return jresult;
85899 }
85900
85901
85902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85903   void * jresult ;
85904   Dali::Toolkit::VisualFactory result;
85905
85906   {
85907     try {
85908       result = Dali::Toolkit::VisualFactory::Get();
85909     } catch (std::out_of_range& e) {
85910       {
85911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85912       };
85913     } catch (std::exception& e) {
85914       {
85915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85916       };
85917     } catch (...) {
85918       {
85919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85920       };
85921     }
85922   }
85923   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85924   return jresult;
85925 }
85926
85927
85928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85929   void * jresult ;
85930   Dali::Toolkit::VisualFactory *result = 0 ;
85931
85932   {
85933     try {
85934       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85935     } catch (std::out_of_range& e) {
85936       {
85937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85938       };
85939     } catch (std::exception& e) {
85940       {
85941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85942       };
85943     } catch (...) {
85944       {
85945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85946       };
85947     }
85948   }
85949   jresult = (void *)result;
85950   return jresult;
85951 }
85952
85953
85954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85955   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85956
85957   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85958   {
85959     try {
85960       delete arg1;
85961     } catch (std::out_of_range& e) {
85962       {
85963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85964       };
85965     } catch (std::exception& e) {
85966       {
85967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85968       };
85969     } catch (...) {
85970       {
85971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85972       };
85973     }
85974   }
85975 }
85976
85977
85978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85979   void * jresult ;
85980   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85981   Dali::Toolkit::VisualFactory *result = 0 ;
85982
85983   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85984   if (!arg1) {
85985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85986     return 0;
85987   }
85988   {
85989     try {
85990       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85991     } catch (std::out_of_range& e) {
85992       {
85993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (std::exception& e) {
85996       {
85997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005   jresult = (void *)result;
86006   return jresult;
86007 }
86008
86009
86010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86011   void * jresult ;
86012   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86013   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86014   Dali::Toolkit::VisualFactory *result = 0 ;
86015
86016   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86017   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86018   if (!arg2) {
86019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86020     return 0;
86021   }
86022   {
86023     try {
86024       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86025     } catch (std::out_of_range& e) {
86026       {
86027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86028       };
86029     } catch (std::exception& e) {
86030       {
86031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86032       };
86033     } catch (...) {
86034       {
86035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86036       };
86037     }
86038   }
86039   jresult = (void *)result;
86040   return jresult;
86041 }
86042
86043
86044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86045   void * jresult ;
86046   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86047   Dali::Property::Map *arg2 = 0 ;
86048   Dali::Toolkit::Visual::Base result;
86049
86050   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86051   arg2 = (Dali::Property::Map *)jarg2;
86052   if (!arg2) {
86053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86054     return 0;
86055   }
86056   {
86057     try {
86058       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86059     } catch (std::out_of_range& e) {
86060       {
86061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (std::exception& e) {
86064       {
86065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86074   return jresult;
86075 }
86076
86077
86078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
86079   void * jresult ;
86080   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86081   Dali::Image *arg2 = 0 ;
86082   Dali::Toolkit::Visual::Base result;
86083
86084   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86085   arg2 = (Dali::Image *)jarg2;
86086   if (!arg2) {
86087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
86088     return 0;
86089   }
86090   {
86091     try {
86092       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
86093     } catch (std::out_of_range& e) {
86094       {
86095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86096       };
86097     } catch (std::exception& e) {
86098       {
86099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86100       };
86101     } catch (...) {
86102       {
86103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86104       };
86105     }
86106   }
86107   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86113   void * jresult ;
86114   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86115   std::string *arg2 = 0 ;
86116   Dali::ImageDimensions arg3 ;
86117   Dali::ImageDimensions *argp3 ;
86118   Dali::Toolkit::Visual::Base result;
86119
86120   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86121   if (!jarg2) {
86122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86123     return 0;
86124   }
86125   std::string arg2_str(jarg2);
86126   arg2 = &arg2_str;
86127   argp3 = (Dali::ImageDimensions *)jarg3;
86128   if (!argp3) {
86129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86130     return 0;
86131   }
86132   arg3 = *argp3;
86133   {
86134     try {
86135       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86136     } catch (std::out_of_range& e) {
86137       {
86138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (std::exception& e) {
86141       {
86142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86147       };
86148     }
86149   }
86150   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86151
86152   //argout typemap for const std::string&
86153
86154   return jresult;
86155 }
86156
86157
86158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86159   void * jresult ;
86160   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86161
86162   {
86163     try {
86164       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86165     } catch (std::out_of_range& e) {
86166       {
86167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86168       };
86169     } catch (std::exception& e) {
86170       {
86171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86172       };
86173     } catch (...) {
86174       {
86175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86176       };
86177     }
86178   }
86179   jresult = (void *)result;
86180   return jresult;
86181 }
86182
86183
86184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86185   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86186
86187   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86188   {
86189     try {
86190       delete arg1;
86191     } catch (std::out_of_range& e) {
86192       {
86193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86194       };
86195     } catch (std::exception& e) {
86196       {
86197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86202       };
86203     }
86204   }
86205 }
86206
86207
86208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86209   void * jresult ;
86210   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86211   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86212
86213   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86214   if (!arg1) {
86215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86216     return 0;
86217   }
86218   {
86219     try {
86220       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86221     } catch (std::out_of_range& e) {
86222       {
86223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86224       };
86225     } catch (std::exception& e) {
86226       {
86227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86228       };
86229     } catch (...) {
86230       {
86231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86232       };
86233     }
86234   }
86235   jresult = (void *)result;
86236   return jresult;
86237 }
86238
86239
86240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86241   void * jresult ;
86242   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86243   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86244   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86245
86246   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86247   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86248   if (!arg2) {
86249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86250     return 0;
86251   }
86252   {
86253     try {
86254       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86255     } catch (std::out_of_range& e) {
86256       {
86257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86258       };
86259     } catch (std::exception& e) {
86260       {
86261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86262       };
86263     } catch (...) {
86264       {
86265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86266       };
86267     }
86268   }
86269   jresult = (void *)result;
86270   return jresult;
86271 }
86272
86273
86274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86275   void * jresult ;
86276   Dali::Toolkit::AsyncImageLoader result;
86277
86278   {
86279     try {
86280       result = Dali::Toolkit::AsyncImageLoader::New();
86281     } catch (std::out_of_range& e) {
86282       {
86283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (std::exception& e) {
86286       {
86287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86288       };
86289     } catch (...) {
86290       {
86291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86292       };
86293     }
86294   }
86295   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86296   return jresult;
86297 }
86298
86299
86300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86301   void * jresult ;
86302   Dali::BaseHandle arg1 ;
86303   Dali::BaseHandle *argp1 ;
86304   Dali::Toolkit::AsyncImageLoader result;
86305
86306   argp1 = (Dali::BaseHandle *)jarg1;
86307   if (!argp1) {
86308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86309     return 0;
86310   }
86311   arg1 = *argp1;
86312   {
86313     try {
86314       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86315     } catch (std::out_of_range& e) {
86316       {
86317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86318       };
86319     } catch (std::exception& e) {
86320       {
86321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (...) {
86324       {
86325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86326       };
86327     }
86328   }
86329   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86330   return jresult;
86331 }
86332
86333
86334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86335   unsigned int jresult ;
86336   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86337   std::string *arg2 = 0 ;
86338   uint32_t result;
86339
86340   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86341   if (!jarg2) {
86342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86343     return 0;
86344   }
86345   std::string arg2_str(jarg2);
86346   arg2 = &arg2_str;
86347   {
86348     try {
86349       result = (arg1)->Load((std::string const &)*arg2);
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (...) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86361       };
86362     }
86363   }
86364   jresult = result;
86365
86366   //argout typemap for const std::string&
86367
86368   return jresult;
86369 }
86370
86371
86372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86373   unsigned int jresult ;
86374   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86375   std::string *arg2 = 0 ;
86376   Dali::ImageDimensions arg3 ;
86377   Dali::ImageDimensions *argp3 ;
86378   uint32_t result;
86379
86380   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86381   if (!jarg2) {
86382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86383     return 0;
86384   }
86385   std::string arg2_str(jarg2);
86386   arg2 = &arg2_str;
86387   argp3 = (Dali::ImageDimensions *)jarg3;
86388   if (!argp3) {
86389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86390     return 0;
86391   }
86392   arg3 = *argp3;
86393   {
86394     try {
86395       result = (arg1)->Load((std::string const &)*arg2,arg3);
86396     } catch (std::out_of_range& e) {
86397       {
86398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86399       };
86400     } catch (std::exception& e) {
86401       {
86402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86403       };
86404     } catch (...) {
86405       {
86406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86407       };
86408     }
86409   }
86410   jresult = result;
86411
86412   //argout typemap for const std::string&
86413
86414   return jresult;
86415 }
86416
86417
86418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86419   unsigned int jresult ;
86420   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86421   std::string *arg2 = 0 ;
86422   Dali::ImageDimensions arg3 ;
86423   Dali::FittingMode::Type arg4 ;
86424   Dali::SamplingMode::Type arg5 ;
86425   bool arg6 ;
86426   Dali::ImageDimensions *argp3 ;
86427   uint32_t result;
86428
86429   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86430   if (!jarg2) {
86431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86432     return 0;
86433   }
86434   std::string arg2_str(jarg2);
86435   arg2 = &arg2_str;
86436   argp3 = (Dali::ImageDimensions *)jarg3;
86437   if (!argp3) {
86438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86439     return 0;
86440   }
86441   arg3 = *argp3;
86442   arg4 = (Dali::FittingMode::Type)jarg4;
86443   arg5 = (Dali::SamplingMode::Type)jarg5;
86444   arg6 = jarg6 ? true : false;
86445   {
86446     try {
86447       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86448     } catch (std::out_of_range& e) {
86449       {
86450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86451       };
86452     } catch (std::exception& e) {
86453       {
86454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86455       };
86456     } catch (...) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86459       };
86460     }
86461   }
86462   jresult = result;
86463
86464   //argout typemap for const std::string&
86465
86466   return jresult;
86467 }
86468
86469
86470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86471   unsigned int jresult ;
86472   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86473   uint32_t arg2 ;
86474   bool result;
86475
86476   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86477   arg2 = (uint32_t)jarg2;
86478   {
86479     try {
86480       result = (bool)(arg1)->Cancel(arg2);
86481     } catch (std::out_of_range& e) {
86482       {
86483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86484       };
86485     } catch (std::exception& e) {
86486       {
86487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86488       };
86489     } catch (...) {
86490       {
86491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86492       };
86493     }
86494   }
86495   jresult = result;
86496   return jresult;
86497 }
86498
86499
86500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86501   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86502
86503   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86504   {
86505     try {
86506       (arg1)->CancelAll();
86507     } catch (std::out_of_range& e) {
86508       {
86509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86510       };
86511     } catch (std::exception& e) {
86512       {
86513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86514       };
86515     } catch (...) {
86516       {
86517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86518       };
86519     }
86520   }
86521 }
86522
86523
86524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86525   void * jresult ;
86526   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86527   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86528
86529   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86530   {
86531     try {
86532       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86533     } catch (std::out_of_range& e) {
86534       {
86535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86536       };
86537     } catch (std::exception& e) {
86538       {
86539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86540       };
86541     } catch (...) {
86542       {
86543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86544       };
86545     }
86546   }
86547   jresult = (void *)result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86553   void * jresult ;
86554   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86555   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86556
86557   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86558   {
86559     try {
86560       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86561     } catch (std::out_of_range& e) {
86562       {
86563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (std::exception& e) {
86566       {
86567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86568       };
86569     } catch (...) {
86570       {
86571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86572       };
86573     }
86574   }
86575   jresult = (void *)result;
86576   return jresult;
86577 }
86578
86579
86580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86581   void * jresult ;
86582   std::string *arg1 = 0 ;
86583   Dali::PixelData result;
86584
86585   if (!jarg1) {
86586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86587     return 0;
86588   }
86589   std::string arg1_str(jarg1);
86590   arg1 = &arg1_str;
86591   {
86592     try {
86593       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86594     } catch (std::out_of_range& e) {
86595       {
86596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86597       };
86598     } catch (std::exception& e) {
86599       {
86600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (...) {
86603       {
86604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86605       };
86606     }
86607   }
86608   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86609
86610   //argout typemap for const std::string&
86611
86612   return jresult;
86613 }
86614
86615
86616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86617   void * jresult ;
86618   std::string *arg1 = 0 ;
86619   Dali::ImageDimensions arg2 ;
86620   Dali::ImageDimensions *argp2 ;
86621   Dali::PixelData result;
86622
86623   if (!jarg1) {
86624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86625     return 0;
86626   }
86627   std::string arg1_str(jarg1);
86628   arg1 = &arg1_str;
86629   argp2 = (Dali::ImageDimensions *)jarg2;
86630   if (!argp2) {
86631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86632     return 0;
86633   }
86634   arg2 = *argp2;
86635   {
86636     try {
86637       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86638     } catch (std::out_of_range& e) {
86639       {
86640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86641       };
86642     } catch (std::exception& e) {
86643       {
86644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86645       };
86646     } catch (...) {
86647       {
86648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86649       };
86650     }
86651   }
86652   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86653
86654   //argout typemap for const std::string&
86655
86656   return jresult;
86657 }
86658
86659
86660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86661   void * jresult ;
86662   std::string *arg1 = 0 ;
86663   Dali::ImageDimensions arg2 ;
86664   Dali::FittingMode::Type arg3 ;
86665   Dali::SamplingMode::Type arg4 ;
86666   bool arg5 ;
86667   Dali::ImageDimensions *argp2 ;
86668   Dali::PixelData result;
86669
86670   if (!jarg1) {
86671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86672     return 0;
86673   }
86674   std::string arg1_str(jarg1);
86675   arg1 = &arg1_str;
86676   argp2 = (Dali::ImageDimensions *)jarg2;
86677   if (!argp2) {
86678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86679     return 0;
86680   }
86681   arg2 = *argp2;
86682   arg3 = (Dali::FittingMode::Type)jarg3;
86683   arg4 = (Dali::SamplingMode::Type)jarg4;
86684   arg5 = jarg5 ? true : false;
86685   {
86686     try {
86687       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86688     } catch (std::out_of_range& e) {
86689       {
86690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86691       };
86692     } catch (std::exception& e) {
86693       {
86694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86695       };
86696     } catch (...) {
86697       {
86698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86699       };
86700     }
86701   }
86702   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86703
86704   //argout typemap for const std::string&
86705
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86711   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86712
86713   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86714   {
86715     try {
86716       delete arg1;
86717     } catch (std::out_of_range& e) {
86718       {
86719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86720       };
86721     } catch (std::exception& e) {
86722       {
86723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86724       };
86725     } catch (...) {
86726       {
86727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86728       };
86729     }
86730   }
86731 }
86732
86733
86734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86735   void * jresult ;
86736   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86737   Dali::Actor arg2 ;
86738   Dali::Actor arg3 ;
86739   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86740   Dali::Actor *argp2 ;
86741   Dali::Actor *argp3 ;
86742   Dali::Actor result;
86743
86744   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86745   argp2 = (Dali::Actor *)jarg2;
86746   if (!argp2) {
86747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86748     return 0;
86749   }
86750   arg2 = *argp2;
86751   argp3 = (Dali::Actor *)jarg3;
86752   if (!argp3) {
86753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86754     return 0;
86755   }
86756   arg3 = *argp3;
86757   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86758   {
86759     try {
86760       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86761     } catch (std::out_of_range& e) {
86762       {
86763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86764       };
86765     } catch (std::exception& e) {
86766       {
86767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86768       };
86769     } catch (...) {
86770       {
86771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86772       };
86773     }
86774   }
86775   jresult = new Dali::Actor((const Dali::Actor &)result);
86776   return jresult;
86777 }
86778
86779
86780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86781   void * jresult ;
86782   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86783
86784   {
86785     try {
86786       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86787     } catch (std::out_of_range& e) {
86788       {
86789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86790       };
86791     } catch (std::exception& e) {
86792       {
86793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86794       };
86795     } catch (...) {
86796       {
86797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86798       };
86799     }
86800   }
86801   jresult = (void *)result;
86802   return jresult;
86803 }
86804
86805
86806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86807   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86808   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86809   if (director) {
86810     director->swig_connect_director(callback0);
86811   }
86812 }
86813
86814
86815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86816   KeyboardFocusManager arg1 ;
86817   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86818   KeyboardFocusManager *argp1 ;
86819
86820   argp1 = (KeyboardFocusManager *)jarg1;
86821   if (!argp1) {
86822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86823     return ;
86824   }
86825   arg1 = *argp1;
86826   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86827   if (!arg2) {
86828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86829     return ;
86830   }
86831   {
86832     try {
86833       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86841       };
86842     } catch (...) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86845       };
86846     }
86847   }
86848 }
86849
86850
86851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86852   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86853
86854   arg1 = (std::vector< unsigned int > *)jarg1;
86855   {
86856     try {
86857       (arg1)->clear();
86858     } catch (std::out_of_range& e) {
86859       {
86860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86861       };
86862     } catch (std::exception& e) {
86863       {
86864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86865       };
86866     } catch (...) {
86867       {
86868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86869       };
86870     }
86871   }
86872 }
86873
86874
86875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86876   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86877   unsigned int *arg2 = 0 ;
86878   unsigned int temp2 ;
86879
86880   arg1 = (std::vector< unsigned int > *)jarg1;
86881   temp2 = (unsigned int)jarg2;
86882   arg2 = &temp2;
86883   {
86884     try {
86885       (arg1)->push_back((unsigned int const &)*arg2);
86886     } catch (std::out_of_range& e) {
86887       {
86888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86889       };
86890     } catch (std::exception& e) {
86891       {
86892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86893       };
86894     } catch (...) {
86895       {
86896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86897       };
86898     }
86899   }
86900 }
86901
86902
86903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86904   unsigned long jresult ;
86905   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86906   std::vector< unsigned int >::size_type result;
86907
86908   arg1 = (std::vector< unsigned int > *)jarg1;
86909   {
86910     try {
86911       result = ((std::vector< unsigned int > const *)arg1)->size();
86912     } catch (std::out_of_range& e) {
86913       {
86914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86915       };
86916     } catch (std::exception& e) {
86917       {
86918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86919       };
86920     } catch (...) {
86921       {
86922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86923       };
86924     }
86925   }
86926   jresult = (unsigned long)result;
86927   return jresult;
86928 }
86929
86930
86931 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86932   unsigned long jresult ;
86933   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86934   std::vector< unsigned int >::size_type result;
86935
86936   arg1 = (std::vector< unsigned int > *)jarg1;
86937   {
86938     try {
86939       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86940     } catch (std::out_of_range& e) {
86941       {
86942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86943       };
86944     } catch (std::exception& e) {
86945       {
86946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86947       };
86948     } catch (...) {
86949       {
86950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86951       };
86952     }
86953   }
86954   jresult = (unsigned long)result;
86955   return jresult;
86956 }
86957
86958
86959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86960   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86961   std::vector< unsigned int >::size_type arg2 ;
86962
86963   arg1 = (std::vector< unsigned int > *)jarg1;
86964   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86965   {
86966     try {
86967       (arg1)->reserve(arg2);
86968     } catch (std::out_of_range& e) {
86969       {
86970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86971       };
86972     } catch (std::exception& e) {
86973       {
86974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86975       };
86976     } catch (...) {
86977       {
86978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86979       };
86980     }
86981   }
86982 }
86983
86984
86985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86986   void * jresult ;
86987   std::vector< unsigned int > *result = 0 ;
86988
86989   {
86990     try {
86991       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86992     } catch (std::out_of_range& e) {
86993       {
86994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86995       };
86996     } catch (std::exception& e) {
86997       {
86998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86999       };
87000     } catch (...) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87003       };
87004     }
87005   }
87006   jresult = (void *)result;
87007   return jresult;
87008 }
87009
87010
87011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87012   void * jresult ;
87013   std::vector< unsigned int > *arg1 = 0 ;
87014   std::vector< unsigned int > *result = 0 ;
87015
87016   arg1 = (std::vector< unsigned int > *)jarg1;
87017   if (!arg1) {
87018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87019     return 0;
87020   }
87021   {
87022     try {
87023       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87024     } catch (std::out_of_range& e) {
87025       {
87026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87027       };
87028     } catch (std::exception& e) {
87029       {
87030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87031       };
87032     } catch (...) {
87033       {
87034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87035       };
87036     }
87037   }
87038   jresult = (void *)result;
87039   return jresult;
87040 }
87041
87042
87043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87044   void * jresult ;
87045   int arg1 ;
87046   std::vector< unsigned int > *result = 0 ;
87047
87048   arg1 = (int)jarg1;
87049   {
87050     try {
87051       try {
87052         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87053       }
87054       catch(std::out_of_range &_e) {
87055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87056         return 0;
87057       }
87058
87059     } catch (std::out_of_range& e) {
87060       {
87061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87062       };
87063     } catch (std::exception& e) {
87064       {
87065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (...) {
87068       {
87069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87070       };
87071     }
87072   }
87073   jresult = (void *)result;
87074   return jresult;
87075 }
87076
87077
87078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87079   unsigned int jresult ;
87080   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87081   int arg2 ;
87082   unsigned int result;
87083
87084   arg1 = (std::vector< unsigned int > *)jarg1;
87085   arg2 = (int)jarg2;
87086   {
87087     try {
87088       try {
87089         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87090       }
87091       catch(std::out_of_range &_e) {
87092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87093         return 0;
87094       }
87095
87096     } catch (std::out_of_range& e) {
87097       {
87098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87099       };
87100     } catch (std::exception& e) {
87101       {
87102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (...) {
87105       {
87106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87107       };
87108     }
87109   }
87110   jresult = result;
87111   return jresult;
87112 }
87113
87114
87115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87116   unsigned int jresult ;
87117   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87118   int arg2 ;
87119   unsigned int *result = 0 ;
87120
87121   arg1 = (std::vector< unsigned int > *)jarg1;
87122   arg2 = (int)jarg2;
87123   {
87124     try {
87125       try {
87126         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87127       }
87128       catch(std::out_of_range &_e) {
87129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87130         return 0;
87131       }
87132
87133     } catch (std::out_of_range& e) {
87134       {
87135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87136       };
87137     } catch (std::exception& e) {
87138       {
87139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87140       };
87141     } catch (...) {
87142       {
87143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87144       };
87145     }
87146   }
87147   jresult = *result;
87148   return jresult;
87149 }
87150
87151
87152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87153   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87154   int arg2 ;
87155   unsigned int *arg3 = 0 ;
87156   unsigned int temp3 ;
87157
87158   arg1 = (std::vector< unsigned int > *)jarg1;
87159   arg2 = (int)jarg2;
87160   temp3 = (unsigned int)jarg3;
87161   arg3 = &temp3;
87162   {
87163     try {
87164       try {
87165         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87166       }
87167       catch(std::out_of_range &_e) {
87168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87169         return ;
87170       }
87171
87172     } catch (std::out_of_range& e) {
87173       {
87174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87175       };
87176     } catch (std::exception& e) {
87177       {
87178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87179       };
87180     } catch (...) {
87181       {
87182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87183       };
87184     }
87185   }
87186 }
87187
87188
87189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87190   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87191   std::vector< unsigned int > *arg2 = 0 ;
87192
87193   arg1 = (std::vector< unsigned int > *)jarg1;
87194   arg2 = (std::vector< unsigned int > *)jarg2;
87195   if (!arg2) {
87196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87197     return ;
87198   }
87199   {
87200     try {
87201       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (...) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87213       };
87214     }
87215   }
87216 }
87217
87218
87219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87220   void * jresult ;
87221   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87222   int arg2 ;
87223   int arg3 ;
87224   std::vector< unsigned int > *result = 0 ;
87225
87226   arg1 = (std::vector< unsigned int > *)jarg1;
87227   arg2 = (int)jarg2;
87228   arg3 = (int)jarg3;
87229   {
87230     try {
87231       try {
87232         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87233       }
87234       catch(std::out_of_range &_e) {
87235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87236         return 0;
87237       }
87238       catch(std::invalid_argument &_e) {
87239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87240         return 0;
87241       }
87242
87243     } catch (std::out_of_range& e) {
87244       {
87245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87246       };
87247     } catch (std::exception& e) {
87248       {
87249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87250       };
87251     } catch (...) {
87252       {
87253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87254       };
87255     }
87256   }
87257   jresult = (void *)result;
87258   return jresult;
87259 }
87260
87261
87262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87264   int arg2 ;
87265   unsigned int *arg3 = 0 ;
87266   unsigned int temp3 ;
87267
87268   arg1 = (std::vector< unsigned int > *)jarg1;
87269   arg2 = (int)jarg2;
87270   temp3 = (unsigned int)jarg3;
87271   arg3 = &temp3;
87272   {
87273     try {
87274       try {
87275         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87276       }
87277       catch(std::out_of_range &_e) {
87278         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87279         return ;
87280       }
87281
87282     } catch (std::out_of_range& e) {
87283       {
87284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87285       };
87286     } catch (std::exception& e) {
87287       {
87288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87289       };
87290     } catch (...) {
87291       {
87292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87293       };
87294     }
87295   }
87296 }
87297
87298
87299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87300   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87301   int arg2 ;
87302   std::vector< unsigned int > *arg3 = 0 ;
87303
87304   arg1 = (std::vector< unsigned int > *)jarg1;
87305   arg2 = (int)jarg2;
87306   arg3 = (std::vector< unsigned int > *)jarg3;
87307   if (!arg3) {
87308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87309     return ;
87310   }
87311   {
87312     try {
87313       try {
87314         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87315       }
87316       catch(std::out_of_range &_e) {
87317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87318         return ;
87319       }
87320
87321     } catch (std::out_of_range& e) {
87322       {
87323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (std::exception& e) {
87326       {
87327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87332       };
87333     }
87334   }
87335 }
87336
87337
87338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87339   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87340   int arg2 ;
87341
87342   arg1 = (std::vector< unsigned int > *)jarg1;
87343   arg2 = (int)jarg2;
87344   {
87345     try {
87346       try {
87347         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87348       }
87349       catch(std::out_of_range &_e) {
87350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87351         return ;
87352       }
87353
87354     } catch (std::out_of_range& e) {
87355       {
87356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87357       };
87358     } catch (std::exception& e) {
87359       {
87360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87361       };
87362     } catch (...) {
87363       {
87364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87365       };
87366     }
87367   }
87368 }
87369
87370
87371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87372   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87373   int arg2 ;
87374   int arg3 ;
87375
87376   arg1 = (std::vector< unsigned int > *)jarg1;
87377   arg2 = (int)jarg2;
87378   arg3 = (int)jarg3;
87379   {
87380     try {
87381       try {
87382         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87383       }
87384       catch(std::out_of_range &_e) {
87385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87386         return ;
87387       }
87388       catch(std::invalid_argument &_e) {
87389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87390         return ;
87391       }
87392
87393     } catch (std::out_of_range& e) {
87394       {
87395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87396       };
87397     } catch (std::exception& e) {
87398       {
87399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87400       };
87401     } catch (...) {
87402       {
87403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87404       };
87405     }
87406   }
87407 }
87408
87409
87410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87411   void * jresult ;
87412   unsigned int *arg1 = 0 ;
87413   int arg2 ;
87414   unsigned int temp1 ;
87415   std::vector< unsigned int > *result = 0 ;
87416
87417   temp1 = (unsigned int)jarg1;
87418   arg1 = &temp1;
87419   arg2 = (int)jarg2;
87420   {
87421     try {
87422       try {
87423         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87424       }
87425       catch(std::out_of_range &_e) {
87426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87427         return 0;
87428       }
87429
87430     } catch (std::out_of_range& e) {
87431       {
87432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87433       };
87434     } catch (std::exception& e) {
87435       {
87436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87437       };
87438     } catch (...) {
87439       {
87440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87441       };
87442     }
87443   }
87444   jresult = (void *)result;
87445   return jresult;
87446 }
87447
87448
87449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87450   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87451
87452   arg1 = (std::vector< unsigned int > *)jarg1;
87453   {
87454     try {
87455       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87456     } catch (std::out_of_range& e) {
87457       {
87458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87459       };
87460     } catch (std::exception& e) {
87461       {
87462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87463       };
87464     } catch (...) {
87465       {
87466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87467       };
87468     }
87469   }
87470 }
87471
87472
87473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87474   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87475   int arg2 ;
87476   int arg3 ;
87477
87478   arg1 = (std::vector< unsigned int > *)jarg1;
87479   arg2 = (int)jarg2;
87480   arg3 = (int)jarg3;
87481   {
87482     try {
87483       try {
87484         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87485       }
87486       catch(std::out_of_range &_e) {
87487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87488         return ;
87489       }
87490       catch(std::invalid_argument &_e) {
87491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87492         return ;
87493       }
87494
87495     } catch (std::out_of_range& e) {
87496       {
87497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87498       };
87499     } catch (std::exception& e) {
87500       {
87501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87502       };
87503     } catch (...) {
87504       {
87505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87506       };
87507     }
87508   }
87509 }
87510
87511
87512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87513   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87514   int arg2 ;
87515   std::vector< unsigned int > *arg3 = 0 ;
87516
87517   arg1 = (std::vector< unsigned int > *)jarg1;
87518   arg2 = (int)jarg2;
87519   arg3 = (std::vector< unsigned int > *)jarg3;
87520   if (!arg3) {
87521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87522     return ;
87523   }
87524   {
87525     try {
87526       try {
87527         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87528       }
87529       catch(std::out_of_range &_e) {
87530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87531         return ;
87532       }
87533
87534     } catch (std::out_of_range& e) {
87535       {
87536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87537       };
87538     } catch (std::exception& e) {
87539       {
87540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87541       };
87542     } catch (...) {
87543       {
87544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87545       };
87546     }
87547   }
87548 }
87549
87550
87551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87552   unsigned int jresult ;
87553   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87554   unsigned int *arg2 = 0 ;
87555   unsigned int temp2 ;
87556   bool result;
87557
87558   arg1 = (std::vector< unsigned int > *)jarg1;
87559   temp2 = (unsigned int)jarg2;
87560   arg2 = &temp2;
87561   {
87562     try {
87563       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87564     } catch (std::out_of_range& e) {
87565       {
87566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87567       };
87568     } catch (std::exception& e) {
87569       {
87570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87571       };
87572     } catch (...) {
87573       {
87574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87575       };
87576     }
87577   }
87578   jresult = result;
87579   return jresult;
87580 }
87581
87582
87583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87584   int jresult ;
87585   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87586   unsigned int *arg2 = 0 ;
87587   unsigned int temp2 ;
87588   int result;
87589
87590   arg1 = (std::vector< unsigned int > *)jarg1;
87591   temp2 = (unsigned int)jarg2;
87592   arg2 = &temp2;
87593   {
87594     try {
87595       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87596     } catch (std::out_of_range& e) {
87597       {
87598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87599       };
87600     } catch (std::exception& e) {
87601       {
87602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87603       };
87604     } catch (...) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87607       };
87608     }
87609   }
87610   jresult = result;
87611   return jresult;
87612 }
87613
87614
87615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87616   int jresult ;
87617   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87618   unsigned int *arg2 = 0 ;
87619   unsigned int temp2 ;
87620   int result;
87621
87622   arg1 = (std::vector< unsigned int > *)jarg1;
87623   temp2 = (unsigned int)jarg2;
87624   arg2 = &temp2;
87625   {
87626     try {
87627       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87628     } catch (std::out_of_range& e) {
87629       {
87630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87631       };
87632     } catch (std::exception& e) {
87633       {
87634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87635       };
87636     } catch (...) {
87637       {
87638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87639       };
87640     }
87641   }
87642   jresult = result;
87643   return jresult;
87644 }
87645
87646
87647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87648   unsigned int jresult ;
87649   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87650   unsigned int *arg2 = 0 ;
87651   unsigned int temp2 ;
87652   bool result;
87653
87654   arg1 = (std::vector< unsigned int > *)jarg1;
87655   temp2 = (unsigned int)jarg2;
87656   arg2 = &temp2;
87657   {
87658     try {
87659       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87660     } catch (std::out_of_range& e) {
87661       {
87662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87663       };
87664     } catch (std::exception& e) {
87665       {
87666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87667       };
87668     } catch (...) {
87669       {
87670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87671       };
87672     }
87673   }
87674   jresult = result;
87675   return jresult;
87676 }
87677
87678
87679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87680   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87681
87682   arg1 = (std::vector< unsigned int > *)jarg1;
87683   {
87684     try {
87685       delete arg1;
87686     } catch (std::out_of_range& e) {
87687       {
87688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (std::exception& e) {
87691       {
87692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87693       };
87694     } catch (...) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87697       };
87698     }
87699   }
87700 }
87701
87702
87703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87704   void * jresult ;
87705   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87706
87707   {
87708     try {
87709       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87710     } catch (std::out_of_range& e) {
87711       {
87712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87713       };
87714     } catch (std::exception& e) {
87715       {
87716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87717       };
87718     } catch (...) {
87719       {
87720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87721       };
87722     }
87723   }
87724   jresult = (void *)result;
87725   return jresult;
87726 }
87727
87728
87729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87730   void * jresult ;
87731   unsigned int arg1 ;
87732   Dali::Actor arg2 ;
87733   Dali::Actor *argp2 ;
87734   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87735
87736   arg1 = (unsigned int)jarg1;
87737   argp2 = (Dali::Actor *)jarg2;
87738   if (!argp2) {
87739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87740     return 0;
87741   }
87742   arg2 = *argp2;
87743   {
87744     try {
87745       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87746     } catch (std::out_of_range& e) {
87747       {
87748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87749       };
87750     } catch (std::exception& e) {
87751       {
87752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87753       };
87754     } catch (...) {
87755       {
87756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87757       };
87758     }
87759   }
87760   jresult = (void *)result;
87761   return jresult;
87762 }
87763
87764
87765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87766   void * jresult ;
87767   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87768   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87769
87770   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87771   if (!arg1) {
87772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87773     return 0;
87774   }
87775   {
87776     try {
87777       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87778     } catch (std::out_of_range& e) {
87779       {
87780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87781       };
87782     } catch (std::exception& e) {
87783       {
87784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87785       };
87786     } catch (...) {
87787       {
87788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87789       };
87790     }
87791   }
87792   jresult = (void *)result;
87793   return jresult;
87794 }
87795
87796
87797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87798   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87799   unsigned int arg2 ;
87800
87801   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87802   arg2 = (unsigned int)jarg2;
87803   if (arg1) (arg1)->first = arg2;
87804 }
87805
87806
87807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87808   unsigned int jresult ;
87809   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87810   unsigned int result;
87811
87812   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87813   result = (unsigned int) ((arg1)->first);
87814   jresult = result;
87815   return jresult;
87816 }
87817
87818
87819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87820   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87821   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87822
87823   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87824   arg2 = (Dali::Actor *)jarg2;
87825   if (arg1) (arg1)->second = *arg2;
87826 }
87827
87828
87829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87830   void * jresult ;
87831   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87832   Dali::Actor *result = 0 ;
87833
87834   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87835   result = (Dali::Actor *)& ((arg1)->second);
87836   jresult = (void *)result;
87837   return jresult;
87838 }
87839
87840
87841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87842   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87843
87844   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87845   {
87846     try {
87847       delete arg1;
87848     } catch (std::out_of_range& e) {
87849       {
87850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87851       };
87852     } catch (std::exception& e) {
87853       {
87854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87855       };
87856     } catch (...) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87859       };
87860     }
87861   }
87862 }
87863
87864
87865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87866   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87867
87868   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87869   {
87870     try {
87871       (arg1)->clear();
87872     } catch (std::out_of_range& e) {
87873       {
87874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87875       };
87876     } catch (std::exception& e) {
87877       {
87878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87879       };
87880     } catch (...) {
87881       {
87882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87883       };
87884     }
87885   }
87886 }
87887
87888
87889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87890   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87891   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87892
87893   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87894   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87895   if (!arg2) {
87896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87897     return ;
87898   }
87899   {
87900     try {
87901       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87902     } catch (std::out_of_range& e) {
87903       {
87904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87905       };
87906     } catch (std::exception& e) {
87907       {
87908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87909       };
87910     } catch (...) {
87911       {
87912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87913       };
87914     }
87915   }
87916 }
87917
87918
87919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87920   unsigned long jresult ;
87921   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87922   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87923
87924   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87925   {
87926     try {
87927       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87928     } catch (std::out_of_range& e) {
87929       {
87930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87931       };
87932     } catch (std::exception& e) {
87933       {
87934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87935       };
87936     } catch (...) {
87937       {
87938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87939       };
87940     }
87941   }
87942   jresult = (unsigned long)result;
87943   return jresult;
87944 }
87945
87946
87947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87948   unsigned long jresult ;
87949   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87950   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87951
87952   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87953   {
87954     try {
87955       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (...) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87967       };
87968     }
87969   }
87970   jresult = (unsigned long)result;
87971   return jresult;
87972 }
87973
87974
87975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87976   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87977   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87978
87979   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87980   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87981   {
87982     try {
87983       (arg1)->reserve(arg2);
87984     } catch (std::out_of_range& e) {
87985       {
87986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87987       };
87988     } catch (std::exception& e) {
87989       {
87990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87991       };
87992     } catch (...) {
87993       {
87994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87995       };
87996     }
87997   }
87998 }
87999
88000
88001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88002   void * jresult ;
88003   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88004
88005   {
88006     try {
88007       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88008     } catch (std::out_of_range& e) {
88009       {
88010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88011       };
88012     } catch (std::exception& e) {
88013       {
88014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88015       };
88016     } catch (...) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88019       };
88020     }
88021   }
88022   jresult = (void *)result;
88023   return jresult;
88024 }
88025
88026
88027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88028   void * jresult ;
88029   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88030   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88031
88032   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88033   if (!arg1) {
88034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88035     return 0;
88036   }
88037   {
88038     try {
88039       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);
88040     } catch (std::out_of_range& e) {
88041       {
88042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88043       };
88044     } catch (std::exception& e) {
88045       {
88046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88047       };
88048     } catch (...) {
88049       {
88050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88051       };
88052     }
88053   }
88054   jresult = (void *)result;
88055   return jresult;
88056 }
88057
88058
88059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88060   void * jresult ;
88061   int arg1 ;
88062   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88063
88064   arg1 = (int)jarg1;
88065   {
88066     try {
88067       try {
88068         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);
88069       }
88070       catch(std::out_of_range &_e) {
88071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88072         return 0;
88073       }
88074
88075     } catch (std::out_of_range& e) {
88076       {
88077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88078       };
88079     } catch (std::exception& e) {
88080       {
88081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88082       };
88083     } catch (...) {
88084       {
88085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88086       };
88087     }
88088   }
88089   jresult = (void *)result;
88090   return jresult;
88091 }
88092
88093
88094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88095   void * jresult ;
88096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88097   int arg2 ;
88098   std::pair< unsigned int,Dali::Actor > result;
88099
88100   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88101   arg2 = (int)jarg2;
88102   {
88103     try {
88104       try {
88105         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88106       }
88107       catch(std::out_of_range &_e) {
88108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88109         return 0;
88110       }
88111
88112     } catch (std::out_of_range& e) {
88113       {
88114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88115       };
88116     } catch (std::exception& e) {
88117       {
88118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88119       };
88120     } catch (...) {
88121       {
88122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88123       };
88124     }
88125   }
88126   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88127   return jresult;
88128 }
88129
88130
88131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88132   void * jresult ;
88133   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88134   int arg2 ;
88135   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88136
88137   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88138   arg2 = (int)jarg2;
88139   {
88140     try {
88141       try {
88142         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88143       }
88144       catch(std::out_of_range &_e) {
88145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88146         return 0;
88147       }
88148
88149     } catch (std::out_of_range& e) {
88150       {
88151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88152       };
88153     } catch (std::exception& e) {
88154       {
88155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88156       };
88157     } catch (...) {
88158       {
88159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88160       };
88161     }
88162   }
88163   jresult = (void *)result;
88164   return jresult;
88165 }
88166
88167
88168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88169   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88170   int arg2 ;
88171   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88172
88173   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88174   arg2 = (int)jarg2;
88175   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88176   if (!arg3) {
88177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88178     return ;
88179   }
88180   {
88181     try {
88182       try {
88183         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);
88184       }
88185       catch(std::out_of_range &_e) {
88186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88187         return ;
88188       }
88189
88190     } catch (std::out_of_range& e) {
88191       {
88192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88193       };
88194     } catch (std::exception& e) {
88195       {
88196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88197       };
88198     } catch (...) {
88199       {
88200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88201       };
88202     }
88203   }
88204 }
88205
88206
88207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88208   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88209   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88210
88211   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88212   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88213   if (!arg2) {
88214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88215     return ;
88216   }
88217   {
88218     try {
88219       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);
88220     } catch (std::out_of_range& e) {
88221       {
88222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88223       };
88224     } catch (std::exception& e) {
88225       {
88226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88227       };
88228     } catch (...) {
88229       {
88230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88231       };
88232     }
88233   }
88234 }
88235
88236
88237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88238   void * jresult ;
88239   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88240   int arg2 ;
88241   int arg3 ;
88242   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88243
88244   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88245   arg2 = (int)jarg2;
88246   arg3 = (int)jarg3;
88247   {
88248     try {
88249       try {
88250         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);
88251       }
88252       catch(std::out_of_range &_e) {
88253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88254         return 0;
88255       }
88256       catch(std::invalid_argument &_e) {
88257         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88258         return 0;
88259       }
88260
88261     } catch (std::out_of_range& e) {
88262       {
88263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88264       };
88265     } catch (std::exception& e) {
88266       {
88267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88268       };
88269     } catch (...) {
88270       {
88271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88272       };
88273     }
88274   }
88275   jresult = (void *)result;
88276   return jresult;
88277 }
88278
88279
88280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88281   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88282   int arg2 ;
88283   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88284
88285   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88286   arg2 = (int)jarg2;
88287   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88288   if (!arg3) {
88289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88290     return ;
88291   }
88292   {
88293     try {
88294       try {
88295         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);
88296       }
88297       catch(std::out_of_range &_e) {
88298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88299         return ;
88300       }
88301
88302     } catch (std::out_of_range& e) {
88303       {
88304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88305       };
88306     } catch (std::exception& e) {
88307       {
88308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88309       };
88310     } catch (...) {
88311       {
88312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88313       };
88314     }
88315   }
88316 }
88317
88318
88319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88320   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88321   int arg2 ;
88322   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88323
88324   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88325   arg2 = (int)jarg2;
88326   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88327   if (!arg3) {
88328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88329     return ;
88330   }
88331   {
88332     try {
88333       try {
88334         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);
88335       }
88336       catch(std::out_of_range &_e) {
88337         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88338         return ;
88339       }
88340
88341     } catch (std::out_of_range& e) {
88342       {
88343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88344       };
88345     } catch (std::exception& e) {
88346       {
88347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88348       };
88349     } catch (...) {
88350       {
88351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88352       };
88353     }
88354   }
88355 }
88356
88357
88358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88359   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88360   int arg2 ;
88361
88362   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88363   arg2 = (int)jarg2;
88364   {
88365     try {
88366       try {
88367         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88368       }
88369       catch(std::out_of_range &_e) {
88370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88371         return ;
88372       }
88373
88374     } catch (std::out_of_range& e) {
88375       {
88376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88377       };
88378     } catch (std::exception& e) {
88379       {
88380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88381       };
88382     } catch (...) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88385       };
88386     }
88387   }
88388 }
88389
88390
88391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88392   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88393   int arg2 ;
88394   int arg3 ;
88395
88396   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88397   arg2 = (int)jarg2;
88398   arg3 = (int)jarg3;
88399   {
88400     try {
88401       try {
88402         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88403       }
88404       catch(std::out_of_range &_e) {
88405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88406         return ;
88407       }
88408       catch(std::invalid_argument &_e) {
88409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88410         return ;
88411       }
88412
88413     } catch (std::out_of_range& e) {
88414       {
88415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88416       };
88417     } catch (std::exception& e) {
88418       {
88419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88420       };
88421     } catch (...) {
88422       {
88423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88424       };
88425     }
88426   }
88427 }
88428
88429
88430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88431   void * jresult ;
88432   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88433   int arg2 ;
88434   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88435
88436   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88437   if (!arg1) {
88438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88439     return 0;
88440   }
88441   arg2 = (int)jarg2;
88442   {
88443     try {
88444       try {
88445         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);
88446       }
88447       catch(std::out_of_range &_e) {
88448         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88449         return 0;
88450       }
88451
88452     } catch (std::out_of_range& e) {
88453       {
88454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88455       };
88456     } catch (std::exception& e) {
88457       {
88458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88459       };
88460     } catch (...) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88463       };
88464     }
88465   }
88466   jresult = (void *)result;
88467   return jresult;
88468 }
88469
88470
88471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88472   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88473
88474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88475   {
88476     try {
88477       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88478     } catch (std::out_of_range& e) {
88479       {
88480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88481       };
88482     } catch (std::exception& e) {
88483       {
88484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88485       };
88486     } catch (...) {
88487       {
88488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88489       };
88490     }
88491   }
88492 }
88493
88494
88495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88496   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88497   int arg2 ;
88498   int arg3 ;
88499
88500   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88501   arg2 = (int)jarg2;
88502   arg3 = (int)jarg3;
88503   {
88504     try {
88505       try {
88506         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88507       }
88508       catch(std::out_of_range &_e) {
88509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88510         return ;
88511       }
88512       catch(std::invalid_argument &_e) {
88513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88514         return ;
88515       }
88516
88517     } catch (std::out_of_range& e) {
88518       {
88519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88520       };
88521     } catch (std::exception& e) {
88522       {
88523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88524       };
88525     } catch (...) {
88526       {
88527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88528       };
88529     }
88530   }
88531 }
88532
88533
88534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88535   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88536   int arg2 ;
88537   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88538
88539   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88540   arg2 = (int)jarg2;
88541   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88542   if (!arg3) {
88543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88544     return ;
88545   }
88546   {
88547     try {
88548       try {
88549         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);
88550       }
88551       catch(std::out_of_range &_e) {
88552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88553         return ;
88554       }
88555
88556     } catch (std::out_of_range& e) {
88557       {
88558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88559       };
88560     } catch (std::exception& e) {
88561       {
88562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88563       };
88564     } catch (...) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88567       };
88568     }
88569   }
88570 }
88571
88572
88573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88574   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88575
88576   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88577   {
88578     try {
88579       delete arg1;
88580     } catch (std::out_of_range& e) {
88581       {
88582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88583       };
88584     } catch (std::exception& e) {
88585       {
88586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88587       };
88588     } catch (...) {
88589       {
88590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88591       };
88592     }
88593   }
88594 }
88595
88596
88597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88598   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88599
88600   arg1 = (std::vector< Dali::Actor > *)jarg1;
88601   {
88602     try {
88603       (arg1)->clear();
88604     } catch (std::out_of_range& e) {
88605       {
88606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88607       };
88608     } catch (std::exception& e) {
88609       {
88610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88611       };
88612     } catch (...) {
88613       {
88614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88615       };
88616     }
88617   }
88618 }
88619
88620
88621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88622   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88623   Dali::Actor *arg2 = 0 ;
88624
88625   arg1 = (std::vector< Dali::Actor > *)jarg1;
88626   arg2 = (Dali::Actor *)jarg2;
88627   if (!arg2) {
88628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88629     return ;
88630   }
88631   {
88632     try {
88633       (arg1)->push_back((Dali::Actor const &)*arg2);
88634     } catch (std::out_of_range& e) {
88635       {
88636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88637       };
88638     } catch (std::exception& e) {
88639       {
88640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88645       };
88646     }
88647   }
88648 }
88649
88650
88651 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88652   unsigned long jresult ;
88653   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88654   std::vector< Dali::Actor >::size_type result;
88655
88656   arg1 = (std::vector< Dali::Actor > *)jarg1;
88657   {
88658     try {
88659       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88660     } catch (std::out_of_range& e) {
88661       {
88662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88663       };
88664     } catch (std::exception& e) {
88665       {
88666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88667       };
88668     } catch (...) {
88669       {
88670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88671       };
88672     }
88673   }
88674   jresult = (unsigned long)result;
88675   return jresult;
88676 }
88677
88678
88679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88680   unsigned long jresult ;
88681   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88682   std::vector< Dali::Actor >::size_type result;
88683
88684   arg1 = (std::vector< Dali::Actor > *)jarg1;
88685   {
88686     try {
88687       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88688     } catch (std::out_of_range& e) {
88689       {
88690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88691       };
88692     } catch (std::exception& e) {
88693       {
88694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88695       };
88696     } catch (...) {
88697       {
88698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88699       };
88700     }
88701   }
88702   jresult = (unsigned long)result;
88703   return jresult;
88704 }
88705
88706
88707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88708   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88709   std::vector< Dali::Actor >::size_type arg2 ;
88710
88711   arg1 = (std::vector< Dali::Actor > *)jarg1;
88712   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88713   {
88714     try {
88715       (arg1)->reserve(arg2);
88716     } catch (std::out_of_range& e) {
88717       {
88718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88719       };
88720     } catch (std::exception& e) {
88721       {
88722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88723       };
88724     } catch (...) {
88725       {
88726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88727       };
88728     }
88729   }
88730 }
88731
88732
88733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88734   void * jresult ;
88735   std::vector< Dali::Actor > *result = 0 ;
88736
88737   {
88738     try {
88739       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88740     } catch (std::out_of_range& e) {
88741       {
88742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88743       };
88744     } catch (std::exception& e) {
88745       {
88746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88751       };
88752     }
88753   }
88754   jresult = (void *)result;
88755   return jresult;
88756 }
88757
88758
88759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88760   void * jresult ;
88761   std::vector< Dali::Actor > *arg1 = 0 ;
88762   std::vector< Dali::Actor > *result = 0 ;
88763
88764   arg1 = (std::vector< Dali::Actor > *)jarg1;
88765   if (!arg1) {
88766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88767     return 0;
88768   }
88769   {
88770     try {
88771       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88772     } catch (std::out_of_range& e) {
88773       {
88774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88775       };
88776     } catch (std::exception& e) {
88777       {
88778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88779       };
88780     } catch (...) {
88781       {
88782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88783       };
88784     }
88785   }
88786   jresult = (void *)result;
88787   return jresult;
88788 }
88789
88790
88791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88792   void * jresult ;
88793   int arg1 ;
88794   std::vector< Dali::Actor > *result = 0 ;
88795
88796   arg1 = (int)jarg1;
88797   {
88798     try {
88799       try {
88800         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88801       }
88802       catch(std::out_of_range &_e) {
88803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88804         return 0;
88805       }
88806
88807     } catch (std::out_of_range& e) {
88808       {
88809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88810       };
88811     } catch (std::exception& e) {
88812       {
88813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88814       };
88815     } catch (...) {
88816       {
88817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88818       };
88819     }
88820   }
88821   jresult = (void *)result;
88822   return jresult;
88823 }
88824
88825
88826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88827   void * jresult ;
88828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88829   int arg2 ;
88830   Dali::Actor result;
88831
88832   arg1 = (std::vector< Dali::Actor > *)jarg1;
88833   arg2 = (int)jarg2;
88834   {
88835     try {
88836       try {
88837         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88838       }
88839       catch(std::out_of_range &_e) {
88840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88841         return 0;
88842       }
88843
88844     } catch (std::out_of_range& e) {
88845       {
88846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88847       };
88848     } catch (std::exception& e) {
88849       {
88850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88851       };
88852     } catch (...) {
88853       {
88854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88855       };
88856     }
88857   }
88858   jresult = new Dali::Actor((const Dali::Actor &)result);
88859   return jresult;
88860 }
88861
88862
88863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88864   void * jresult ;
88865   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88866   int arg2 ;
88867   Dali::Actor *result = 0 ;
88868
88869   arg1 = (std::vector< Dali::Actor > *)jarg1;
88870   arg2 = (int)jarg2;
88871   {
88872     try {
88873       try {
88874         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88875       }
88876       catch(std::out_of_range &_e) {
88877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88878         return 0;
88879       }
88880
88881     } catch (std::out_of_range& e) {
88882       {
88883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88884       };
88885     } catch (std::exception& e) {
88886       {
88887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88888       };
88889     } catch (...) {
88890       {
88891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88892       };
88893     }
88894   }
88895   jresult = (void *)result;
88896   return jresult;
88897 }
88898
88899
88900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88901   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88902   int arg2 ;
88903   Dali::Actor *arg3 = 0 ;
88904
88905   arg1 = (std::vector< Dali::Actor > *)jarg1;
88906   arg2 = (int)jarg2;
88907   arg3 = (Dali::Actor *)jarg3;
88908   if (!arg3) {
88909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88910     return ;
88911   }
88912   {
88913     try {
88914       try {
88915         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88916       }
88917       catch(std::out_of_range &_e) {
88918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88919         return ;
88920       }
88921
88922     } catch (std::out_of_range& e) {
88923       {
88924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88925       };
88926     } catch (std::exception& e) {
88927       {
88928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88933       };
88934     }
88935   }
88936 }
88937
88938
88939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88941   std::vector< Dali::Actor > *arg2 = 0 ;
88942
88943   arg1 = (std::vector< Dali::Actor > *)jarg1;
88944   arg2 = (std::vector< Dali::Actor > *)jarg2;
88945   if (!arg2) {
88946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88947     return ;
88948   }
88949   {
88950     try {
88951       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88952     } catch (std::out_of_range& e) {
88953       {
88954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88955       };
88956     } catch (std::exception& e) {
88957       {
88958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88959       };
88960     } catch (...) {
88961       {
88962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88963       };
88964     }
88965   }
88966 }
88967
88968
88969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88970   void * jresult ;
88971   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88972   int arg2 ;
88973   int arg3 ;
88974   std::vector< Dali::Actor > *result = 0 ;
88975
88976   arg1 = (std::vector< Dali::Actor > *)jarg1;
88977   arg2 = (int)jarg2;
88978   arg3 = (int)jarg3;
88979   {
88980     try {
88981       try {
88982         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88983       }
88984       catch(std::out_of_range &_e) {
88985         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88986         return 0;
88987       }
88988       catch(std::invalid_argument &_e) {
88989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88990         return 0;
88991       }
88992
88993     } catch (std::out_of_range& e) {
88994       {
88995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88996       };
88997     } catch (std::exception& e) {
88998       {
88999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89000       };
89001     } catch (...) {
89002       {
89003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89004       };
89005     }
89006   }
89007   jresult = (void *)result;
89008   return jresult;
89009 }
89010
89011
89012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89013   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89014   int arg2 ;
89015   Dali::Actor *arg3 = 0 ;
89016
89017   arg1 = (std::vector< Dali::Actor > *)jarg1;
89018   arg2 = (int)jarg2;
89019   arg3 = (Dali::Actor *)jarg3;
89020   if (!arg3) {
89021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89022     return ;
89023   }
89024   {
89025     try {
89026       try {
89027         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89028       }
89029       catch(std::out_of_range &_e) {
89030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89031         return ;
89032       }
89033
89034     } catch (std::out_of_range& e) {
89035       {
89036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89037       };
89038     } catch (std::exception& e) {
89039       {
89040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89041       };
89042     } catch (...) {
89043       {
89044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89045       };
89046     }
89047   }
89048 }
89049
89050
89051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89052   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89053   int arg2 ;
89054   std::vector< Dali::Actor > *arg3 = 0 ;
89055
89056   arg1 = (std::vector< Dali::Actor > *)jarg1;
89057   arg2 = (int)jarg2;
89058   arg3 = (std::vector< Dali::Actor > *)jarg3;
89059   if (!arg3) {
89060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89061     return ;
89062   }
89063   {
89064     try {
89065       try {
89066         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89067       }
89068       catch(std::out_of_range &_e) {
89069         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89070         return ;
89071       }
89072
89073     } catch (std::out_of_range& e) {
89074       {
89075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89076       };
89077     } catch (std::exception& e) {
89078       {
89079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89080       };
89081     } catch (...) {
89082       {
89083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89084       };
89085     }
89086   }
89087 }
89088
89089
89090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89091   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89092   int arg2 ;
89093
89094   arg1 = (std::vector< Dali::Actor > *)jarg1;
89095   arg2 = (int)jarg2;
89096   {
89097     try {
89098       try {
89099         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89100       }
89101       catch(std::out_of_range &_e) {
89102         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89103         return ;
89104       }
89105
89106     } catch (std::out_of_range& e) {
89107       {
89108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89109       };
89110     } catch (std::exception& e) {
89111       {
89112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89113       };
89114     } catch (...) {
89115       {
89116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89117       };
89118     }
89119   }
89120 }
89121
89122
89123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89124   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89125   int arg2 ;
89126   int arg3 ;
89127
89128   arg1 = (std::vector< Dali::Actor > *)jarg1;
89129   arg2 = (int)jarg2;
89130   arg3 = (int)jarg3;
89131   {
89132     try {
89133       try {
89134         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89135       }
89136       catch(std::out_of_range &_e) {
89137         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89138         return ;
89139       }
89140       catch(std::invalid_argument &_e) {
89141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89142         return ;
89143       }
89144
89145     } catch (std::out_of_range& e) {
89146       {
89147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89148       };
89149     } catch (std::exception& e) {
89150       {
89151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89152       };
89153     } catch (...) {
89154       {
89155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89156       };
89157     }
89158   }
89159 }
89160
89161
89162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89163   void * jresult ;
89164   Dali::Actor *arg1 = 0 ;
89165   int arg2 ;
89166   std::vector< Dali::Actor > *result = 0 ;
89167
89168   arg1 = (Dali::Actor *)jarg1;
89169   if (!arg1) {
89170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89171     return 0;
89172   }
89173   arg2 = (int)jarg2;
89174   {
89175     try {
89176       try {
89177         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89178       }
89179       catch(std::out_of_range &_e) {
89180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89181         return 0;
89182       }
89183
89184     } catch (std::out_of_range& e) {
89185       {
89186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89187       };
89188     } catch (std::exception& e) {
89189       {
89190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89191       };
89192     } catch (...) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89195       };
89196     }
89197   }
89198   jresult = (void *)result;
89199   return jresult;
89200 }
89201
89202
89203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89204   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89205
89206   arg1 = (std::vector< Dali::Actor > *)jarg1;
89207   {
89208     try {
89209       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89210     } catch (std::out_of_range& e) {
89211       {
89212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89213       };
89214     } catch (std::exception& e) {
89215       {
89216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89217       };
89218     } catch (...) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89221       };
89222     }
89223   }
89224 }
89225
89226
89227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89228   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89229   int arg2 ;
89230   int arg3 ;
89231
89232   arg1 = (std::vector< Dali::Actor > *)jarg1;
89233   arg2 = (int)jarg2;
89234   arg3 = (int)jarg3;
89235   {
89236     try {
89237       try {
89238         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89239       }
89240       catch(std::out_of_range &_e) {
89241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89242         return ;
89243       }
89244       catch(std::invalid_argument &_e) {
89245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89246         return ;
89247       }
89248
89249     } catch (std::out_of_range& e) {
89250       {
89251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89252       };
89253     } catch (std::exception& e) {
89254       {
89255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89256       };
89257     } catch (...) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89260       };
89261     }
89262   }
89263 }
89264
89265
89266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89267   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89268   int arg2 ;
89269   std::vector< Dali::Actor > *arg3 = 0 ;
89270
89271   arg1 = (std::vector< Dali::Actor > *)jarg1;
89272   arg2 = (int)jarg2;
89273   arg3 = (std::vector< Dali::Actor > *)jarg3;
89274   if (!arg3) {
89275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89276     return ;
89277   }
89278   {
89279     try {
89280       try {
89281         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89282       }
89283       catch(std::out_of_range &_e) {
89284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89285         return ;
89286       }
89287
89288     } catch (std::out_of_range& e) {
89289       {
89290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89291       };
89292     } catch (std::exception& e) {
89293       {
89294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89295       };
89296     } catch (...) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89299       };
89300     }
89301   }
89302 }
89303
89304
89305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89306   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89307
89308   arg1 = (std::vector< Dali::Actor > *)jarg1;
89309   {
89310     try {
89311       delete arg1;
89312     } catch (std::out_of_range& e) {
89313       {
89314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89315       };
89316     } catch (std::exception& e) {
89317       {
89318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89319       };
89320     } catch (...) {
89321       {
89322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89323       };
89324     }
89325   }
89326 }
89327
89328
89329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89330   unsigned int jresult ;
89331   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89332   bool result;
89333
89334   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89335   {
89336     try {
89337       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89338     } catch (std::out_of_range& e) {
89339       {
89340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89341       };
89342     } catch (std::exception& e) {
89343       {
89344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89345       };
89346     } catch (...) {
89347       {
89348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89349       };
89350     }
89351   }
89352   jresult = result;
89353   return jresult;
89354 }
89355
89356
89357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89358   unsigned long jresult ;
89359   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89360   std::size_t result;
89361
89362   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89363   {
89364     try {
89365       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89366     } catch (std::out_of_range& e) {
89367       {
89368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89369       };
89370     } catch (std::exception& e) {
89371       {
89372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89373       };
89374     } catch (...) {
89375       {
89376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89377       };
89378     }
89379   }
89380   jresult = (unsigned long)result;
89381   return jresult;
89382 }
89383
89384
89385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89386   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89387   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89388
89389   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89390   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89391   {
89392     try {
89393       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89394     } catch (std::out_of_range& e) {
89395       {
89396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89397       };
89398     } catch (std::exception& e) {
89399       {
89400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89401       };
89402     } catch (...) {
89403       {
89404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89405       };
89406     }
89407   }
89408 }
89409
89410
89411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89412   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89413   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89414
89415   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89416   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89417   {
89418     try {
89419       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89420     } catch (std::out_of_range& e) {
89421       {
89422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89423       };
89424     } catch (std::exception& e) {
89425       {
89426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89427       };
89428     } catch (...) {
89429       {
89430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89431       };
89432     }
89433   }
89434 }
89435
89436
89437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89438   unsigned int jresult ;
89439   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89440   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89441   bool result;
89442
89443   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89444   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89445   if (!arg2) {
89446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89447     return 0;
89448   }
89449   {
89450     try {
89451       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89452     } catch (std::out_of_range& e) {
89453       {
89454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (std::exception& e) {
89457       {
89458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89463       };
89464     }
89465   }
89466   jresult = result;
89467   return jresult;
89468 }
89469
89470
89471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89472   void * jresult ;
89473   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89474
89475   {
89476     try {
89477       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89478     } catch (std::out_of_range& e) {
89479       {
89480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89481       };
89482     } catch (std::exception& e) {
89483       {
89484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89485       };
89486     } catch (...) {
89487       {
89488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89489       };
89490     }
89491   }
89492   jresult = (void *)result;
89493   return jresult;
89494 }
89495
89496
89497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89498   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89499
89500   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89501   {
89502     try {
89503       delete arg1;
89504     } catch (std::out_of_range& e) {
89505       {
89506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89507       };
89508     } catch (std::exception& e) {
89509       {
89510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (...) {
89513       {
89514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89515       };
89516     }
89517   }
89518 }
89519
89520
89521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89522   unsigned int jresult ;
89523   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89524   bool result;
89525
89526   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89527   {
89528     try {
89529       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);
89530     } catch (std::out_of_range& e) {
89531       {
89532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89533       };
89534     } catch (std::exception& e) {
89535       {
89536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89537       };
89538     } catch (...) {
89539       {
89540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89541       };
89542     }
89543   }
89544   jresult = result;
89545   return jresult;
89546 }
89547
89548
89549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89550   unsigned long jresult ;
89551   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89552   std::size_t result;
89553
89554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89555   {
89556     try {
89557       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);
89558     } catch (std::out_of_range& e) {
89559       {
89560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89561       };
89562     } catch (std::exception& e) {
89563       {
89564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89565       };
89566     } catch (...) {
89567       {
89568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89569       };
89570     }
89571   }
89572   jresult = (unsigned long)result;
89573   return jresult;
89574 }
89575
89576
89577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89578   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89579   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89580
89581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89582   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89583   {
89584     try {
89585       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89586     } catch (std::out_of_range& e) {
89587       {
89588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89589       };
89590     } catch (std::exception& e) {
89591       {
89592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89593       };
89594     } catch (...) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89597       };
89598     }
89599   }
89600 }
89601
89602
89603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89604   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89605   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89606
89607   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89608   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89609   {
89610     try {
89611       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89612     } catch (std::out_of_range& e) {
89613       {
89614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89615       };
89616     } catch (std::exception& e) {
89617       {
89618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89619       };
89620     } catch (...) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89623       };
89624     }
89625   }
89626 }
89627
89628
89629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89630   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89631   Dali::Actor arg2 ;
89632   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89633   Dali::Actor *argp2 ;
89634
89635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89636   argp2 = (Dali::Actor *)jarg2;
89637   if (!argp2) {
89638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89639     return ;
89640   }
89641   arg2 = *argp2;
89642   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89643   {
89644     try {
89645       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89646     } catch (std::out_of_range& e) {
89647       {
89648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89649       };
89650     } catch (std::exception& e) {
89651       {
89652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89657       };
89658     }
89659   }
89660 }
89661
89662
89663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89664   void * jresult ;
89665   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89666
89667   {
89668     try {
89669       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89670     } catch (std::out_of_range& e) {
89671       {
89672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89673       };
89674     } catch (std::exception& e) {
89675       {
89676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89677       };
89678     } catch (...) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89681       };
89682     }
89683   }
89684   jresult = (void *)result;
89685   return jresult;
89686 }
89687
89688
89689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89690   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89691
89692   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89693   {
89694     try {
89695       delete arg1;
89696     } catch (std::out_of_range& e) {
89697       {
89698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89699       };
89700     } catch (std::exception& e) {
89701       {
89702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89703       };
89704     } catch (...) {
89705       {
89706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89707       };
89708     }
89709   }
89710 }
89711
89712
89713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89714   unsigned int jresult ;
89715   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89716   bool result;
89717
89718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89719   {
89720     try {
89721       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89722     } catch (std::out_of_range& e) {
89723       {
89724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89725       };
89726     } catch (std::exception& e) {
89727       {
89728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89729       };
89730     } catch (...) {
89731       {
89732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89733       };
89734     }
89735   }
89736   jresult = result;
89737   return jresult;
89738 }
89739
89740
89741 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89742   unsigned long jresult ;
89743   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89744   std::size_t result;
89745
89746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89747   {
89748     try {
89749       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89750     } catch (std::out_of_range& e) {
89751       {
89752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89753       };
89754     } catch (std::exception& e) {
89755       {
89756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89757       };
89758     } catch (...) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89761       };
89762     }
89763   }
89764   jresult = (unsigned long)result;
89765   return jresult;
89766 }
89767
89768
89769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89770   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89771   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89772
89773   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89774   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89775   {
89776     try {
89777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89778     } catch (std::out_of_range& e) {
89779       {
89780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89781       };
89782     } catch (std::exception& e) {
89783       {
89784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89785       };
89786     } catch (...) {
89787       {
89788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89789       };
89790     }
89791   }
89792 }
89793
89794
89795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89796   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89797   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89798
89799   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89800   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89801   {
89802     try {
89803       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89804     } catch (std::out_of_range& e) {
89805       {
89806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89807       };
89808     } catch (std::exception& e) {
89809       {
89810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89815       };
89816     }
89817   }
89818 }
89819
89820
89821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89822   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89823   Dali::Actor arg2 ;
89824   Dali::Actor arg3 ;
89825   Dali::Actor *argp2 ;
89826   Dali::Actor *argp3 ;
89827
89828   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89829   argp2 = (Dali::Actor *)jarg2;
89830   if (!argp2) {
89831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89832     return ;
89833   }
89834   arg2 = *argp2;
89835   argp3 = (Dali::Actor *)jarg3;
89836   if (!argp3) {
89837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89838     return ;
89839   }
89840   arg3 = *argp3;
89841   {
89842     try {
89843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89844     } catch (std::out_of_range& e) {
89845       {
89846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89847       };
89848     } catch (std::exception& e) {
89849       {
89850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89851       };
89852     } catch (...) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89855       };
89856     }
89857   }
89858 }
89859
89860
89861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89862   void * jresult ;
89863   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89864
89865   {
89866     try {
89867       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89868     } catch (std::out_of_range& e) {
89869       {
89870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (std::exception& e) {
89873       {
89874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89879       };
89880     }
89881   }
89882   jresult = (void *)result;
89883   return jresult;
89884 }
89885
89886
89887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89888   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89889
89890   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89891   {
89892     try {
89893       delete arg1;
89894     } catch (std::out_of_range& e) {
89895       {
89896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89897       };
89898     } catch (std::exception& e) {
89899       {
89900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89901       };
89902     } catch (...) {
89903       {
89904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89905       };
89906     }
89907   }
89908 }
89909
89910
89911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89912   unsigned int jresult ;
89913   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89914   bool result;
89915
89916   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89917   {
89918     try {
89919       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89920     } catch (std::out_of_range& e) {
89921       {
89922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (std::exception& e) {
89925       {
89926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89931       };
89932     }
89933   }
89934   jresult = result;
89935   return jresult;
89936 }
89937
89938
89939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89940   unsigned long jresult ;
89941   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89942   std::size_t result;
89943
89944   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89945   {
89946     try {
89947       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89948     } catch (std::out_of_range& e) {
89949       {
89950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89951       };
89952     } catch (std::exception& e) {
89953       {
89954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89955       };
89956     } catch (...) {
89957       {
89958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89959       };
89960     }
89961   }
89962   jresult = (unsigned long)result;
89963   return jresult;
89964 }
89965
89966
89967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89968   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89969   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89970
89971   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89972   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89973   {
89974     try {
89975       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89976     } catch (std::out_of_range& e) {
89977       {
89978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89979       };
89980     } catch (std::exception& e) {
89981       {
89982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89983       };
89984     } catch (...) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89987       };
89988     }
89989   }
89990 }
89991
89992
89993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89994   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89995   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89996
89997   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89998   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89999   {
90000     try {
90001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90009       };
90010     } catch (...) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90013       };
90014     }
90015   }
90016 }
90017
90018
90019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90020   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90021   Dali::Actor arg2 ;
90022   bool arg3 ;
90023   Dali::Actor *argp2 ;
90024
90025   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90026   argp2 = (Dali::Actor *)jarg2;
90027   if (!argp2) {
90028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90029     return ;
90030   }
90031   arg2 = *argp2;
90032   arg3 = jarg3 ? true : false;
90033   {
90034     try {
90035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90036     } catch (std::out_of_range& e) {
90037       {
90038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90039       };
90040     } catch (std::exception& e) {
90041       {
90042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90043       };
90044     } catch (...) {
90045       {
90046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90047       };
90048     }
90049   }
90050 }
90051
90052
90053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90054   void * jresult ;
90055   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90056
90057   {
90058     try {
90059       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90060     } catch (std::out_of_range& e) {
90061       {
90062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (std::exception& e) {
90065       {
90066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90067       };
90068     } catch (...) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90071       };
90072     }
90073   }
90074   jresult = (void *)result;
90075   return jresult;
90076 }
90077
90078
90079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90080   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90081
90082   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90083   {
90084     try {
90085       delete arg1;
90086     } catch (std::out_of_range& e) {
90087       {
90088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90089       };
90090     } catch (std::exception& e) {
90091       {
90092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90097       };
90098     }
90099   }
90100 }
90101
90102
90103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90104   unsigned int jresult ;
90105   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90106   bool result;
90107
90108   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90109   {
90110     try {
90111       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);
90112     } catch (std::out_of_range& e) {
90113       {
90114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90115       };
90116     } catch (std::exception& e) {
90117       {
90118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90119       };
90120     } catch (...) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90123       };
90124     }
90125   }
90126   jresult = result;
90127   return jresult;
90128 }
90129
90130
90131 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90132   unsigned long jresult ;
90133   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90134   std::size_t result;
90135
90136   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90137   {
90138     try {
90139       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);
90140     } catch (std::out_of_range& e) {
90141       {
90142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90143       };
90144     } catch (std::exception& e) {
90145       {
90146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90151       };
90152     }
90153   }
90154   jresult = (unsigned long)result;
90155   return jresult;
90156 }
90157
90158
90159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90160   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90161   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90162
90163   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90164   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90165   {
90166     try {
90167       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90168     } catch (std::out_of_range& e) {
90169       {
90170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90171       };
90172     } catch (std::exception& e) {
90173       {
90174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90175       };
90176     } catch (...) {
90177       {
90178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90179       };
90180     }
90181   }
90182 }
90183
90184
90185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90186   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90187   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90188
90189   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90190   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90191   {
90192     try {
90193       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90194     } catch (std::out_of_range& e) {
90195       {
90196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90197       };
90198     } catch (std::exception& e) {
90199       {
90200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90201       };
90202     } catch (...) {
90203       {
90204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90205       };
90206     }
90207   }
90208 }
90209
90210
90211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90212   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90213   Dali::Toolkit::StyleManager arg2 ;
90214   Dali::StyleChange::Type arg3 ;
90215   Dali::Toolkit::StyleManager *argp2 ;
90216
90217   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90218   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90219   if (!argp2) {
90220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90221     return ;
90222   }
90223   arg2 = *argp2;
90224   arg3 = (Dali::StyleChange::Type)jarg3;
90225   {
90226     try {
90227       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90228     } catch (std::out_of_range& e) {
90229       {
90230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90231       };
90232     } catch (std::exception& e) {
90233       {
90234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90235       };
90236     } catch (...) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90239       };
90240     }
90241   }
90242 }
90243
90244
90245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90246   void * jresult ;
90247   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90248
90249   {
90250     try {
90251       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90252     } catch (std::out_of_range& e) {
90253       {
90254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90255       };
90256     } catch (std::exception& e) {
90257       {
90258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90259       };
90260     } catch (...) {
90261       {
90262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90263       };
90264     }
90265   }
90266   jresult = (void *)result;
90267   return jresult;
90268 }
90269
90270
90271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90272   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90273
90274   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90275   {
90276     try {
90277       delete arg1;
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90285       };
90286     } catch (...) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90289       };
90290     }
90291   }
90292 }
90293
90294
90295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90296   unsigned int jresult ;
90297   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90298   bool result;
90299
90300   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90301   {
90302     try {
90303       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90304     } catch (std::out_of_range& e) {
90305       {
90306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90307       };
90308     } catch (std::exception& e) {
90309       {
90310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90311       };
90312     } catch (...) {
90313       {
90314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90315       };
90316     }
90317   }
90318   jresult = result;
90319   return jresult;
90320 }
90321
90322
90323 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90324   unsigned long jresult ;
90325   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90326   std::size_t result;
90327
90328   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90329   {
90330     try {
90331       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90332     } catch (std::out_of_range& e) {
90333       {
90334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90335       };
90336     } catch (std::exception& e) {
90337       {
90338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90339       };
90340     } catch (...) {
90341       {
90342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90343       };
90344     }
90345   }
90346   jresult = (unsigned long)result;
90347   return jresult;
90348 }
90349
90350
90351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90352   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90353   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90354
90355   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90356   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90357   {
90358     try {
90359       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90360     } catch (std::out_of_range& e) {
90361       {
90362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90363       };
90364     } catch (std::exception& e) {
90365       {
90366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90367       };
90368     } catch (...) {
90369       {
90370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90371       };
90372     }
90373   }
90374 }
90375
90376
90377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90378   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90379   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90380
90381   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90382   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90383   {
90384     try {
90385       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90386     } catch (std::out_of_range& e) {
90387       {
90388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90389       };
90390     } catch (std::exception& e) {
90391       {
90392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90393       };
90394     } catch (...) {
90395       {
90396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90397       };
90398     }
90399   }
90400 }
90401
90402
90403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90404   unsigned int jresult ;
90405   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90406   Dali::Toolkit::Button arg2 ;
90407   Dali::Toolkit::Button *argp2 ;
90408   bool result;
90409
90410   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90411   argp2 = (Dali::Toolkit::Button *)jarg2;
90412   if (!argp2) {
90413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90414     return 0;
90415   }
90416   arg2 = *argp2;
90417   {
90418     try {
90419       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90420     } catch (std::out_of_range& e) {
90421       {
90422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (std::exception& e) {
90425       {
90426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434   jresult = result;
90435   return jresult;
90436 }
90437
90438
90439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90440   void * jresult ;
90441   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90442
90443   {
90444     try {
90445       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90446     } catch (std::out_of_range& e) {
90447       {
90448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90449       };
90450     } catch (std::exception& e) {
90451       {
90452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90453       };
90454     } catch (...) {
90455       {
90456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90457       };
90458     }
90459   }
90460   jresult = (void *)result;
90461   return jresult;
90462 }
90463
90464
90465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90466   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90467
90468   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90469   {
90470     try {
90471       delete arg1;
90472     } catch (std::out_of_range& e) {
90473       {
90474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90475       };
90476     } catch (std::exception& e) {
90477       {
90478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90479       };
90480     } catch (...) {
90481       {
90482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90483       };
90484     }
90485   }
90486 }
90487
90488
90489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90490   unsigned int jresult ;
90491   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90492   bool result;
90493
90494   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90495   {
90496     try {
90497       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90498     } catch (std::out_of_range& e) {
90499       {
90500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90501       };
90502     } catch (std::exception& e) {
90503       {
90504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90509       };
90510     }
90511   }
90512   jresult = result;
90513   return jresult;
90514 }
90515
90516
90517 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90518   unsigned long jresult ;
90519   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90520   std::size_t result;
90521
90522   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90523   {
90524     try {
90525       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90526     } catch (std::out_of_range& e) {
90527       {
90528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90529       };
90530     } catch (std::exception& e) {
90531       {
90532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90533       };
90534     } catch (...) {
90535       {
90536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90537       };
90538     }
90539   }
90540   jresult = (unsigned long)result;
90541   return jresult;
90542 }
90543
90544
90545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90546   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90547   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90548
90549   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90550   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90551   {
90552     try {
90553       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90554     } catch (std::out_of_range& e) {
90555       {
90556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90557       };
90558     } catch (std::exception& e) {
90559       {
90560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90565       };
90566     }
90567   }
90568 }
90569
90570
90571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90572   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90573   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90574
90575   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90576   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90577   {
90578     try {
90579       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90580     } catch (std::out_of_range& e) {
90581       {
90582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90583       };
90584     } catch (std::exception& e) {
90585       {
90586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90587       };
90588     } catch (...) {
90589       {
90590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90591       };
90592     }
90593   }
90594 }
90595
90596
90597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90598   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90599   Dali::Toolkit::GaussianBlurView arg2 ;
90600   Dali::Toolkit::GaussianBlurView *argp2 ;
90601
90602   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90603   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90604   if (!argp2) {
90605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90606     return ;
90607   }
90608   arg2 = *argp2;
90609   {
90610     try {
90611       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90612     } catch (std::out_of_range& e) {
90613       {
90614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90615       };
90616     } catch (std::exception& e) {
90617       {
90618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90619       };
90620     } catch (...) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90623       };
90624     }
90625   }
90626 }
90627
90628
90629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90630   void * jresult ;
90631   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90632
90633   {
90634     try {
90635       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90636     } catch (std::out_of_range& e) {
90637       {
90638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90639       };
90640     } catch (std::exception& e) {
90641       {
90642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90643       };
90644     } catch (...) {
90645       {
90646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90647       };
90648     }
90649   }
90650   jresult = (void *)result;
90651   return jresult;
90652 }
90653
90654
90655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90656   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90657
90658   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90659   {
90660     try {
90661       delete arg1;
90662     } catch (std::out_of_range& e) {
90663       {
90664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90665       };
90666     } catch (std::exception& e) {
90667       {
90668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90669       };
90670     } catch (...) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90673       };
90674     }
90675   }
90676 }
90677
90678
90679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90680   unsigned int jresult ;
90681   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90682   bool result;
90683
90684   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90685   {
90686     try {
90687       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);
90688     } catch (std::out_of_range& e) {
90689       {
90690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90691       };
90692     } catch (std::exception& e) {
90693       {
90694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90695       };
90696     } catch (...) {
90697       {
90698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90699       };
90700     }
90701   }
90702   jresult = result;
90703   return jresult;
90704 }
90705
90706
90707 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90708   unsigned long jresult ;
90709   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90710   std::size_t result;
90711
90712   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90713   {
90714     try {
90715       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);
90716     } catch (std::out_of_range& e) {
90717       {
90718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90719       };
90720     } catch (std::exception& e) {
90721       {
90722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90723       };
90724     } catch (...) {
90725       {
90726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90727       };
90728     }
90729   }
90730   jresult = (unsigned long)result;
90731   return jresult;
90732 }
90733
90734
90735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90736   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90737   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90738
90739   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90740   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90741   {
90742     try {
90743       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90744     } catch (std::out_of_range& e) {
90745       {
90746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90747       };
90748     } catch (std::exception& e) {
90749       {
90750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90751       };
90752     } catch (...) {
90753       {
90754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90755       };
90756     }
90757   }
90758 }
90759
90760
90761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90762   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90763   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90764
90765   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90766   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90767   {
90768     try {
90769       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90770     } catch (std::out_of_range& e) {
90771       {
90772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90773       };
90774     } catch (std::exception& e) {
90775       {
90776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90777       };
90778     } catch (...) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90781       };
90782     }
90783   }
90784 }
90785
90786
90787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90788   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90789   Dali::Toolkit::PageTurnView arg2 ;
90790   unsigned int arg3 ;
90791   bool arg4 ;
90792   Dali::Toolkit::PageTurnView *argp2 ;
90793
90794   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90795   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90796   if (!argp2) {
90797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90798     return ;
90799   }
90800   arg2 = *argp2;
90801   arg3 = (unsigned int)jarg3;
90802   arg4 = jarg4 ? true : false;
90803   {
90804     try {
90805       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90806     } catch (std::out_of_range& e) {
90807       {
90808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90809       };
90810     } catch (std::exception& e) {
90811       {
90812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90813       };
90814     } catch (...) {
90815       {
90816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90817       };
90818     }
90819   }
90820 }
90821
90822
90823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90824   void * jresult ;
90825   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90826
90827   {
90828     try {
90829       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90837       };
90838     } catch (...) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90841       };
90842     }
90843   }
90844   jresult = (void *)result;
90845   return jresult;
90846 }
90847
90848
90849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90850   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90851
90852   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90853   {
90854     try {
90855       delete arg1;
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90863       };
90864     } catch (...) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90867       };
90868     }
90869   }
90870 }
90871
90872
90873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90874   unsigned int jresult ;
90875   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90876   bool result;
90877
90878   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90879   {
90880     try {
90881       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90882     } catch (std::out_of_range& e) {
90883       {
90884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90885       };
90886     } catch (std::exception& e) {
90887       {
90888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (...) {
90891       {
90892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90893       };
90894     }
90895   }
90896   jresult = result;
90897   return jresult;
90898 }
90899
90900
90901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90902   unsigned long jresult ;
90903   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90904   std::size_t result;
90905
90906   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90907   {
90908     try {
90909       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90910     } catch (std::out_of_range& e) {
90911       {
90912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90913       };
90914     } catch (std::exception& e) {
90915       {
90916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90917       };
90918     } catch (...) {
90919       {
90920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90921       };
90922     }
90923   }
90924   jresult = (unsigned long)result;
90925   return jresult;
90926 }
90927
90928
90929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90930   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90931   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90932
90933   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90934   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90935   {
90936     try {
90937       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90938     } catch (std::out_of_range& e) {
90939       {
90940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90941       };
90942     } catch (std::exception& e) {
90943       {
90944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90945       };
90946     } catch (...) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90949       };
90950     }
90951   }
90952 }
90953
90954
90955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90956   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90957   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90958
90959   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90960   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90961   {
90962     try {
90963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90964     } catch (std::out_of_range& e) {
90965       {
90966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90967       };
90968     } catch (std::exception& e) {
90969       {
90970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90971       };
90972     } catch (...) {
90973       {
90974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90975       };
90976     }
90977   }
90978 }
90979
90980
90981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90982   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90983   Dali::Toolkit::PageTurnView arg2 ;
90984   Dali::Toolkit::PageTurnView *argp2 ;
90985
90986   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90987   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90988   if (!argp2) {
90989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90990     return ;
90991   }
90992   arg2 = *argp2;
90993   {
90994     try {
90995       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90996     } catch (std::out_of_range& e) {
90997       {
90998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90999       };
91000     } catch (std::exception& e) {
91001       {
91002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91003       };
91004     } catch (...) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91007       };
91008     }
91009   }
91010 }
91011
91012
91013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91014   void * jresult ;
91015   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91016
91017   {
91018     try {
91019       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91020     } catch (std::out_of_range& e) {
91021       {
91022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91023       };
91024     } catch (std::exception& e) {
91025       {
91026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91027       };
91028     } catch (...) {
91029       {
91030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91031       };
91032     }
91033   }
91034   jresult = (void *)result;
91035   return jresult;
91036 }
91037
91038
91039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91040   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91041
91042   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91043   {
91044     try {
91045       delete arg1;
91046     } catch (std::out_of_range& e) {
91047       {
91048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91049       };
91050     } catch (std::exception& e) {
91051       {
91052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91053       };
91054     } catch (...) {
91055       {
91056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91057       };
91058     }
91059   }
91060 }
91061
91062
91063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91064   unsigned int jresult ;
91065   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91066   bool result;
91067
91068   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91069   {
91070     try {
91071       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);
91072     } catch (std::out_of_range& e) {
91073       {
91074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91075       };
91076     } catch (std::exception& e) {
91077       {
91078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91079       };
91080     } catch (...) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91083       };
91084     }
91085   }
91086   jresult = result;
91087   return jresult;
91088 }
91089
91090
91091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91092   unsigned long jresult ;
91093   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91094   std::size_t result;
91095
91096   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91097   {
91098     try {
91099       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);
91100     } catch (std::out_of_range& e) {
91101       {
91102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91103       };
91104     } catch (std::exception& e) {
91105       {
91106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91107       };
91108     } catch (...) {
91109       {
91110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91111       };
91112     }
91113   }
91114   jresult = (unsigned long)result;
91115   return jresult;
91116 }
91117
91118
91119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91120   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91121   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91122
91123   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91124   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91125   {
91126     try {
91127       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91128     } catch (std::out_of_range& e) {
91129       {
91130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91131       };
91132     } catch (std::exception& e) {
91133       {
91134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91135       };
91136     } catch (...) {
91137       {
91138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91139       };
91140     }
91141   }
91142 }
91143
91144
91145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91146   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91147   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91148
91149   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91150   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91151   {
91152     try {
91153       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91154     } catch (std::out_of_range& e) {
91155       {
91156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91157       };
91158     } catch (std::exception& e) {
91159       {
91160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91161       };
91162     } catch (...) {
91163       {
91164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91165       };
91166     }
91167   }
91168 }
91169
91170
91171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91172   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91173   Dali::Toolkit::ProgressBar arg2 ;
91174   float arg3 ;
91175   float arg4 ;
91176   Dali::Toolkit::ProgressBar *argp2 ;
91177
91178   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91179   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91180   if (!argp2) {
91181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91182     return ;
91183   }
91184   arg2 = *argp2;
91185   arg3 = (float)jarg3;
91186   arg4 = (float)jarg4;
91187   {
91188     try {
91189       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91190     } catch (std::out_of_range& e) {
91191       {
91192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91193       };
91194     } catch (std::exception& e) {
91195       {
91196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91197       };
91198     } catch (...) {
91199       {
91200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91201       };
91202     }
91203   }
91204 }
91205
91206
91207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91208   void * jresult ;
91209   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91210
91211   {
91212     try {
91213       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91214     } catch (std::out_of_range& e) {
91215       {
91216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91217       };
91218     } catch (std::exception& e) {
91219       {
91220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91221       };
91222     } catch (...) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91225       };
91226     }
91227   }
91228   jresult = (void *)result;
91229   return jresult;
91230 }
91231
91232
91233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91234   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91235
91236   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91237   {
91238     try {
91239       delete arg1;
91240     } catch (std::out_of_range& e) {
91241       {
91242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91243       };
91244     } catch (std::exception& e) {
91245       {
91246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91247       };
91248     } catch (...) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91251       };
91252     }
91253   }
91254 }
91255
91256
91257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91258   unsigned int jresult ;
91259   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91260   bool result;
91261
91262   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91263   {
91264     try {
91265       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);
91266     } catch (std::out_of_range& e) {
91267       {
91268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91269       };
91270     } catch (std::exception& e) {
91271       {
91272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91273       };
91274     } catch (...) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91277       };
91278     }
91279   }
91280   jresult = result;
91281   return jresult;
91282 }
91283
91284
91285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91286   unsigned long jresult ;
91287   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91288   std::size_t result;
91289
91290   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91291   {
91292     try {
91293       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);
91294     } catch (std::out_of_range& e) {
91295       {
91296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91297       };
91298     } catch (std::exception& e) {
91299       {
91300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91301       };
91302     } catch (...) {
91303       {
91304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91305       };
91306     }
91307   }
91308   jresult = (unsigned long)result;
91309   return jresult;
91310 }
91311
91312
91313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91314   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91315   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91316
91317   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91318   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91319   {
91320     try {
91321       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91322     } catch (std::out_of_range& e) {
91323       {
91324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91325       };
91326     } catch (std::exception& e) {
91327       {
91328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91329       };
91330     } catch (...) {
91331       {
91332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91333       };
91334     }
91335   }
91336 }
91337
91338
91339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91340   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91341   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91342
91343   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91344   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91345   {
91346     try {
91347       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91348     } catch (std::out_of_range& e) {
91349       {
91350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91351       };
91352     } catch (std::exception& e) {
91353       {
91354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91355       };
91356     } catch (...) {
91357       {
91358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91359       };
91360     }
91361   }
91362 }
91363
91364
91365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91366   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91367   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91368
91369   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91370   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91371   if (!arg2) {
91372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91373     return ;
91374   }
91375   {
91376     try {
91377       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91378     } catch (std::out_of_range& e) {
91379       {
91380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91381       };
91382     } catch (std::exception& e) {
91383       {
91384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91385       };
91386     } catch (...) {
91387       {
91388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91389       };
91390     }
91391   }
91392 }
91393
91394
91395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91396   void * jresult ;
91397   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91398
91399   {
91400     try {
91401       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91402     } catch (std::out_of_range& e) {
91403       {
91404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91405       };
91406     } catch (std::exception& e) {
91407       {
91408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91409       };
91410     } catch (...) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91413       };
91414     }
91415   }
91416   jresult = (void *)result;
91417   return jresult;
91418 }
91419
91420
91421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91422   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91423
91424   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91425   {
91426     try {
91427       delete arg1;
91428     } catch (std::out_of_range& e) {
91429       {
91430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91431       };
91432     } catch (std::exception& e) {
91433       {
91434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91435       };
91436     } catch (...) {
91437       {
91438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91439       };
91440     }
91441   }
91442 }
91443
91444
91445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91446   unsigned int jresult ;
91447   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91448   bool result;
91449
91450   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91451   {
91452     try {
91453       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91454     } catch (std::out_of_range& e) {
91455       {
91456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91457       };
91458     } catch (std::exception& e) {
91459       {
91460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91461       };
91462     } catch (...) {
91463       {
91464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91465       };
91466     }
91467   }
91468   jresult = result;
91469   return jresult;
91470 }
91471
91472
91473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91474   unsigned long jresult ;
91475   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91476   std::size_t result;
91477
91478   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91479   {
91480     try {
91481       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91482     } catch (std::out_of_range& e) {
91483       {
91484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (std::exception& e) {
91487       {
91488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91489       };
91490     } catch (...) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91493       };
91494     }
91495   }
91496   jresult = (unsigned long)result;
91497   return jresult;
91498 }
91499
91500
91501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91502   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91503   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91504
91505   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91506   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91507   {
91508     try {
91509       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91510     } catch (std::out_of_range& e) {
91511       {
91512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91513       };
91514     } catch (std::exception& e) {
91515       {
91516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91517       };
91518     } catch (...) {
91519       {
91520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91521       };
91522     }
91523   }
91524 }
91525
91526
91527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91528   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91529   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91530
91531   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91532   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91533   {
91534     try {
91535       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91536     } catch (std::out_of_range& e) {
91537       {
91538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91539       };
91540     } catch (std::exception& e) {
91541       {
91542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91543       };
91544     } catch (...) {
91545       {
91546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91547       };
91548     }
91549   }
91550 }
91551
91552
91553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91554   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91555   Dali::Vector2 *arg2 = 0 ;
91556
91557   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91558   arg2 = (Dali::Vector2 *)jarg2;
91559   if (!arg2) {
91560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91561     return ;
91562   }
91563   {
91564     try {
91565       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91566     } catch (std::out_of_range& e) {
91567       {
91568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91569       };
91570     } catch (std::exception& e) {
91571       {
91572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91573       };
91574     } catch (...) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91577       };
91578     }
91579   }
91580 }
91581
91582
91583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91584   void * jresult ;
91585   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91586
91587   {
91588     try {
91589       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91590     } catch (std::out_of_range& e) {
91591       {
91592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91593       };
91594     } catch (std::exception& e) {
91595       {
91596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91597       };
91598     } catch (...) {
91599       {
91600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91601       };
91602     }
91603   }
91604   jresult = (void *)result;
91605   return jresult;
91606 }
91607
91608
91609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91610   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91611
91612   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91613   {
91614     try {
91615       delete arg1;
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91623       };
91624     } catch (...) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91627       };
91628     }
91629   }
91630 }
91631
91632
91633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91634   unsigned int jresult ;
91635   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91636   bool result;
91637
91638   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91639   {
91640     try {
91641       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91649       };
91650     } catch (...) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91653       };
91654     }
91655   }
91656   jresult = result;
91657   return jresult;
91658 }
91659
91660
91661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91662   unsigned long jresult ;
91663   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91664   std::size_t result;
91665
91666   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91667   {
91668     try {
91669       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91670     } catch (std::out_of_range& e) {
91671       {
91672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91673       };
91674     } catch (std::exception& e) {
91675       {
91676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91677       };
91678     } catch (...) {
91679       {
91680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91681       };
91682     }
91683   }
91684   jresult = (unsigned long)result;
91685   return jresult;
91686 }
91687
91688
91689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91690   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91691   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91692
91693   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91694   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91695   {
91696     try {
91697       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91698     } catch (std::out_of_range& e) {
91699       {
91700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91701       };
91702     } catch (std::exception& e) {
91703       {
91704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91705       };
91706     } catch (...) {
91707       {
91708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91709       };
91710     }
91711   }
91712 }
91713
91714
91715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91716   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91717   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91718
91719   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91720   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91721   {
91722     try {
91723       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91724     } catch (std::out_of_range& e) {
91725       {
91726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91727       };
91728     } catch (std::exception& e) {
91729       {
91730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91731       };
91732     } catch (...) {
91733       {
91734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91735       };
91736     }
91737   }
91738 }
91739
91740
91741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91742   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91743   Dali::Toolkit::TextEditor arg2 ;
91744   Dali::Toolkit::TextEditor *argp2 ;
91745
91746   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91747   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91748   if (!argp2) {
91749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91750     return ;
91751   }
91752   arg2 = *argp2;
91753   {
91754     try {
91755       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91756     } catch (std::out_of_range& e) {
91757       {
91758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91759       };
91760     } catch (std::exception& e) {
91761       {
91762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91763       };
91764     } catch (...) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91767       };
91768     }
91769   }
91770 }
91771
91772
91773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91774   void * jresult ;
91775   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91776
91777   {
91778     try {
91779       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91780     } catch (std::out_of_range& e) {
91781       {
91782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91783       };
91784     } catch (std::exception& e) {
91785       {
91786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91787       };
91788     } catch (...) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91791       };
91792     }
91793   }
91794   jresult = (void *)result;
91795   return jresult;
91796 }
91797
91798
91799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91800   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91801
91802   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91803   {
91804     try {
91805       delete arg1;
91806     } catch (std::out_of_range& e) {
91807       {
91808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91809       };
91810     } catch (std::exception& e) {
91811       {
91812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91813       };
91814     } catch (...) {
91815       {
91816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91817       };
91818     }
91819   }
91820 }
91821
91822
91823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91824   unsigned int jresult ;
91825   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91826   bool result;
91827
91828   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91829   {
91830     try {
91831       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91843       };
91844     }
91845   }
91846   jresult = result;
91847   return jresult;
91848 }
91849
91850
91851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91852   unsigned long jresult ;
91853   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91854   std::size_t result;
91855
91856   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91857   {
91858     try {
91859       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91860     } catch (std::out_of_range& e) {
91861       {
91862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91863       };
91864     } catch (std::exception& e) {
91865       {
91866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91867       };
91868     } catch (...) {
91869       {
91870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91871       };
91872     }
91873   }
91874   jresult = (unsigned long)result;
91875   return jresult;
91876 }
91877
91878
91879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91880   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91881   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91882
91883   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91884   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91885   {
91886     try {
91887       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91888     } catch (std::out_of_range& e) {
91889       {
91890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91891       };
91892     } catch (std::exception& e) {
91893       {
91894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91895       };
91896     } catch (...) {
91897       {
91898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91899       };
91900     }
91901   }
91902 }
91903
91904
91905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91906   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91907   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91908
91909   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91910   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91911   {
91912     try {
91913       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91914     } catch (std::out_of_range& e) {
91915       {
91916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91917       };
91918     } catch (std::exception& e) {
91919       {
91920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91921       };
91922     } catch (...) {
91923       {
91924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91925       };
91926     }
91927   }
91928 }
91929
91930
91931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91932   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91933   Dali::Toolkit::TextField arg2 ;
91934   Dali::Toolkit::TextField *argp2 ;
91935
91936   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91937   argp2 = (Dali::Toolkit::TextField *)jarg2;
91938   if (!argp2) {
91939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91940     return ;
91941   }
91942   arg2 = *argp2;
91943   {
91944     try {
91945       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91953       };
91954     } catch (...) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91957       };
91958     }
91959   }
91960 }
91961
91962
91963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91964   void * jresult ;
91965   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91966
91967   {
91968     try {
91969       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91970     } catch (std::out_of_range& e) {
91971       {
91972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91973       };
91974     } catch (std::exception& e) {
91975       {
91976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91977       };
91978     } catch (...) {
91979       {
91980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91981       };
91982     }
91983   }
91984   jresult = (void *)result;
91985   return jresult;
91986 }
91987
91988
91989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91990   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91991
91992   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91993   {
91994     try {
91995       delete arg1;
91996     } catch (std::out_of_range& e) {
91997       {
91998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91999       };
92000     } catch (std::exception& e) {
92001       {
92002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92003       };
92004     } catch (...) {
92005       {
92006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92007       };
92008     }
92009   }
92010 }
92011
92012
92013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92014   unsigned int jresult ;
92015   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92016   bool result;
92017
92018   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92019   {
92020     try {
92021       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);
92022     } catch (std::out_of_range& e) {
92023       {
92024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92025       };
92026     } catch (std::exception& e) {
92027       {
92028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (...) {
92031       {
92032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92033       };
92034     }
92035   }
92036   jresult = result;
92037   return jresult;
92038 }
92039
92040
92041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92042   unsigned long jresult ;
92043   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92044   std::size_t result;
92045
92046   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92047   {
92048     try {
92049       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);
92050     } catch (std::out_of_range& e) {
92051       {
92052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (std::exception& e) {
92055       {
92056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92057       };
92058     } catch (...) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92061       };
92062     }
92063   }
92064   jresult = (unsigned long)result;
92065   return jresult;
92066 }
92067
92068
92069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92070   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92071   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92072
92073   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92074   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92075   {
92076     try {
92077       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92078     } catch (std::out_of_range& e) {
92079       {
92080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92081       };
92082     } catch (std::exception& e) {
92083       {
92084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92085       };
92086     } catch (...) {
92087       {
92088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92089       };
92090     }
92091   }
92092 }
92093
92094
92095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92096   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92097   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92098
92099   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92100   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92101   {
92102     try {
92103       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (...) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92115       };
92116     }
92117   }
92118 }
92119
92120
92121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92122   unsigned int jresult ;
92123   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92124   Dali::Toolkit::Control arg2 ;
92125   Dali::KeyEvent *arg3 = 0 ;
92126   Dali::Toolkit::Control *argp2 ;
92127   bool result;
92128
92129   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92130   argp2 = (Dali::Toolkit::Control *)jarg2;
92131   if (!argp2) {
92132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92133     return 0;
92134   }
92135   arg2 = *argp2;
92136   arg3 = (Dali::KeyEvent *)jarg3;
92137   if (!arg3) {
92138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92139     return 0;
92140   }
92141   {
92142     try {
92143       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);
92144     } catch (std::out_of_range& e) {
92145       {
92146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92147       };
92148     } catch (std::exception& e) {
92149       {
92150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92151       };
92152     } catch (...) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92155       };
92156     }
92157   }
92158   jresult = result;
92159   return jresult;
92160 }
92161
92162
92163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92164   void * jresult ;
92165   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92166
92167   {
92168     try {
92169       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92170     } catch (std::out_of_range& e) {
92171       {
92172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92173       };
92174     } catch (std::exception& e) {
92175       {
92176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92177       };
92178     } catch (...) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92181       };
92182     }
92183   }
92184   jresult = (void *)result;
92185   return jresult;
92186 }
92187
92188
92189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92190   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92191
92192   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92193   {
92194     try {
92195       delete arg1;
92196     } catch (std::out_of_range& e) {
92197       {
92198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92199       };
92200     } catch (std::exception& e) {
92201       {
92202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92203       };
92204     } catch (...) {
92205       {
92206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92207       };
92208     }
92209   }
92210 }
92211
92212
92213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92214   unsigned int jresult ;
92215   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92216   bool result;
92217
92218   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92219   {
92220     try {
92221       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (...) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92233       };
92234     }
92235   }
92236   jresult = result;
92237   return jresult;
92238 }
92239
92240
92241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92242   unsigned long jresult ;
92243   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92244   std::size_t result;
92245
92246   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92247   {
92248     try {
92249       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92250     } catch (std::out_of_range& e) {
92251       {
92252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92253       };
92254     } catch (std::exception& e) {
92255       {
92256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (...) {
92259       {
92260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92261       };
92262     }
92263   }
92264   jresult = (unsigned long)result;
92265   return jresult;
92266 }
92267
92268
92269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92270   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92271   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92272
92273   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92274   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92275   {
92276     try {
92277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92278     } catch (std::out_of_range& e) {
92279       {
92280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92281       };
92282     } catch (std::exception& e) {
92283       {
92284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92285       };
92286     } catch (...) {
92287       {
92288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92289       };
92290     }
92291   }
92292 }
92293
92294
92295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92296   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92297   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92298
92299   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92300   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92301   {
92302     try {
92303       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92304     } catch (std::out_of_range& e) {
92305       {
92306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92307       };
92308     } catch (std::exception& e) {
92309       {
92310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92311       };
92312     } catch (...) {
92313       {
92314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92315       };
92316     }
92317   }
92318 }
92319
92320
92321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92322   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92323   Dali::Toolkit::Control arg2 ;
92324   Dali::Toolkit::Control *argp2 ;
92325
92326   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92327   argp2 = (Dali::Toolkit::Control *)jarg2;
92328   if (!argp2) {
92329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92330     return ;
92331   }
92332   arg2 = *argp2;
92333   {
92334     try {
92335       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92336     } catch (std::out_of_range& e) {
92337       {
92338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92339       };
92340     } catch (std::exception& e) {
92341       {
92342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92343       };
92344     } catch (...) {
92345       {
92346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92347       };
92348     }
92349   }
92350 }
92351
92352
92353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92354   void * jresult ;
92355   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92356
92357   {
92358     try {
92359       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92360     } catch (std::out_of_range& e) {
92361       {
92362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92363       };
92364     } catch (std::exception& e) {
92365       {
92366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92367       };
92368     } catch (...) {
92369       {
92370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92371       };
92372     }
92373   }
92374   jresult = (void *)result;
92375   return jresult;
92376 }
92377
92378
92379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92380   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92381
92382   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92383   {
92384     try {
92385       delete arg1;
92386     } catch (std::out_of_range& e) {
92387       {
92388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92389       };
92390     } catch (std::exception& e) {
92391       {
92392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92393       };
92394     } catch (...) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92397       };
92398     }
92399   }
92400 }
92401
92402
92403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92404   unsigned int jresult ;
92405   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92406   bool result;
92407
92408   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92409   {
92410     try {
92411       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92412     } catch (std::out_of_range& e) {
92413       {
92414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92415       };
92416     } catch (std::exception& e) {
92417       {
92418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92419       };
92420     } catch (...) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92423       };
92424     }
92425   }
92426   jresult = result;
92427   return jresult;
92428 }
92429
92430
92431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92432   unsigned long jresult ;
92433   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92434   std::size_t result;
92435
92436   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92437   {
92438     try {
92439       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92440     } catch (std::out_of_range& e) {
92441       {
92442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92443       };
92444     } catch (std::exception& e) {
92445       {
92446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92447       };
92448     } catch (...) {
92449       {
92450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92451       };
92452     }
92453   }
92454   jresult = (unsigned long)result;
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92460   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92461   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92462
92463   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92464   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92465   {
92466     try {
92467       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92468     } catch (std::out_of_range& e) {
92469       {
92470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92471       };
92472     } catch (std::exception& e) {
92473       {
92474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92475       };
92476     } catch (...) {
92477       {
92478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92479       };
92480     }
92481   }
92482 }
92483
92484
92485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92486   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92487   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92488
92489   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92490   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92491   {
92492     try {
92493       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92501       };
92502     } catch (...) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92505       };
92506     }
92507   }
92508 }
92509
92510
92511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92512   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92513   Dali::Toolkit::VideoView *arg2 = 0 ;
92514
92515   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92516   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92517   if (!arg2) {
92518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92519     return ;
92520   }
92521   {
92522     try {
92523       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92524     } catch (std::out_of_range& e) {
92525       {
92526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92527       };
92528     } catch (std::exception& e) {
92529       {
92530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92531       };
92532     } catch (...) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92535       };
92536     }
92537   }
92538 }
92539
92540
92541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92542   void * jresult ;
92543   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92544
92545   {
92546     try {
92547       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92548     } catch (std::out_of_range& e) {
92549       {
92550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92551       };
92552     } catch (std::exception& e) {
92553       {
92554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92555       };
92556     } catch (...) {
92557       {
92558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92559       };
92560     }
92561   }
92562   jresult = (void *)result;
92563   return jresult;
92564 }
92565
92566
92567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92568   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92569
92570   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92571   {
92572     try {
92573       delete arg1;
92574     } catch (std::out_of_range& e) {
92575       {
92576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92577       };
92578     } catch (std::exception& e) {
92579       {
92580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92581       };
92582     } catch (...) {
92583       {
92584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92585       };
92586     }
92587   }
92588 }
92589
92590
92591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92592   unsigned int jresult ;
92593   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92594   bool result;
92595
92596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92597   {
92598     try {
92599       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92600     } catch (std::out_of_range& e) {
92601       {
92602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92603       };
92604     } catch (std::exception& e) {
92605       {
92606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (...) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92611       };
92612     }
92613   }
92614   jresult = result;
92615   return jresult;
92616 }
92617
92618
92619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92620   unsigned long jresult ;
92621   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92622   std::size_t result;
92623
92624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92625   {
92626     try {
92627       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92628     } catch (std::out_of_range& e) {
92629       {
92630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92631       };
92632     } catch (std::exception& e) {
92633       {
92634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92639       };
92640     }
92641   }
92642   jresult = (unsigned long)result;
92643   return jresult;
92644 }
92645
92646
92647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92648   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92649   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92650
92651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92652   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92653   {
92654     try {
92655       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92656     } catch (std::out_of_range& e) {
92657       {
92658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92659       };
92660     } catch (std::exception& e) {
92661       {
92662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92663       };
92664     } catch (...) {
92665       {
92666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92667       };
92668     }
92669   }
92670 }
92671
92672
92673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92674   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92675   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92676
92677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92678   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92679   {
92680     try {
92681       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92682     } catch (std::out_of_range& e) {
92683       {
92684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92685       };
92686     } catch (std::exception& e) {
92687       {
92688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92689       };
92690     } catch (...) {
92691       {
92692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92693       };
92694     }
92695   }
92696 }
92697
92698
92699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92700   unsigned int jresult ;
92701   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92702   Dali::Toolkit::Slider arg2 ;
92703   float arg3 ;
92704   Dali::Toolkit::Slider *argp2 ;
92705   bool result;
92706
92707   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92708   argp2 = (Dali::Toolkit::Slider *)jarg2;
92709   if (!argp2) {
92710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92711     return 0;
92712   }
92713   arg2 = *argp2;
92714   arg3 = (float)jarg3;
92715   {
92716     try {
92717       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92718     } catch (std::out_of_range& e) {
92719       {
92720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92721       };
92722     } catch (std::exception& e) {
92723       {
92724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92725       };
92726     } catch (...) {
92727       {
92728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92729       };
92730     }
92731   }
92732   jresult = result;
92733   return jresult;
92734 }
92735
92736
92737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92738   void * jresult ;
92739   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92740
92741   {
92742     try {
92743       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92744     } catch (std::out_of_range& e) {
92745       {
92746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92747       };
92748     } catch (std::exception& e) {
92749       {
92750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92751       };
92752     } catch (...) {
92753       {
92754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92755       };
92756     }
92757   }
92758   jresult = (void *)result;
92759   return jresult;
92760 }
92761
92762
92763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92764   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92765
92766   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92767   {
92768     try {
92769       delete arg1;
92770     } catch (std::out_of_range& e) {
92771       {
92772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92773       };
92774     } catch (std::exception& e) {
92775       {
92776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92777       };
92778     } catch (...) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92781       };
92782     }
92783   }
92784 }
92785
92786
92787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92788   unsigned int jresult ;
92789   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92790   bool result;
92791
92792   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92793   {
92794     try {
92795       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92796     } catch (std::out_of_range& e) {
92797       {
92798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92799       };
92800     } catch (std::exception& e) {
92801       {
92802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92803       };
92804     } catch (...) {
92805       {
92806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92807       };
92808     }
92809   }
92810   jresult = result;
92811   return jresult;
92812 }
92813
92814
92815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92816   unsigned long jresult ;
92817   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92818   std::size_t result;
92819
92820   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92821   {
92822     try {
92823       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92824     } catch (std::out_of_range& e) {
92825       {
92826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92827       };
92828     } catch (std::exception& e) {
92829       {
92830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92831       };
92832     } catch (...) {
92833       {
92834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92835       };
92836     }
92837   }
92838   jresult = (unsigned long)result;
92839   return jresult;
92840 }
92841
92842
92843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92844   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92845   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92846
92847   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92848   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92849   {
92850     try {
92851       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92852     } catch (std::out_of_range& e) {
92853       {
92854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92855       };
92856     } catch (std::exception& e) {
92857       {
92858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92859       };
92860     } catch (...) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92863       };
92864     }
92865   }
92866 }
92867
92868
92869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92870   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92871   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92872
92873   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92874   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92875   {
92876     try {
92877       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92878     } catch (std::out_of_range& e) {
92879       {
92880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (std::exception& e) {
92883       {
92884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92885       };
92886     } catch (...) {
92887       {
92888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92889       };
92890     }
92891   }
92892 }
92893
92894
92895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92896   unsigned int jresult ;
92897   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92898   Dali::Toolkit::Slider arg2 ;
92899   int arg3 ;
92900   Dali::Toolkit::Slider *argp2 ;
92901   bool result;
92902
92903   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92904   argp2 = (Dali::Toolkit::Slider *)jarg2;
92905   if (!argp2) {
92906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92907     return 0;
92908   }
92909   arg2 = *argp2;
92910   arg3 = (int)jarg3;
92911   {
92912     try {
92913       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92914     } catch (std::out_of_range& e) {
92915       {
92916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92917       };
92918     } catch (std::exception& e) {
92919       {
92920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92921       };
92922     } catch (...) {
92923       {
92924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92925       };
92926     }
92927   }
92928   jresult = result;
92929   return jresult;
92930 }
92931
92932
92933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92934   void * jresult ;
92935   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92936
92937   {
92938     try {
92939       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92940     } catch (std::out_of_range& e) {
92941       {
92942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92943       };
92944     } catch (std::exception& e) {
92945       {
92946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92947       };
92948     } catch (...) {
92949       {
92950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92951       };
92952     }
92953   }
92954   jresult = (void *)result;
92955   return jresult;
92956 }
92957
92958
92959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92960   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92961
92962   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92963   {
92964     try {
92965       delete arg1;
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92973       };
92974     } catch (...) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92977       };
92978     }
92979   }
92980 }
92981
92982
92983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92984   void * jresult ;
92985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92986
92987   {
92988     try {
92989       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92990     } catch (std::out_of_range& e) {
92991       {
92992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92993       };
92994     } catch (std::exception& e) {
92995       {
92996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92997       };
92998     } catch (...) {
92999       {
93000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93001       };
93002     }
93003   }
93004   jresult = (void *)result;
93005   return jresult;
93006 }
93007
93008
93009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93010   void * jresult ;
93011   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93012   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93013
93014   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93015   {
93016     try {
93017       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93018     } catch (std::out_of_range& e) {
93019       {
93020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93021       };
93022     } catch (std::exception& e) {
93023       {
93024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93025       };
93026     } catch (...) {
93027       {
93028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93029       };
93030     }
93031   }
93032   jresult = (void *)result;
93033   return jresult;
93034 }
93035
93036
93037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93038   void * jresult ;
93039   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93040   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93041
93042   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93043   if (!arg1) {
93044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93045     return 0;
93046   }
93047   {
93048     try {
93049       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93050     } catch (std::out_of_range& e) {
93051       {
93052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93053       };
93054     } catch (std::exception& e) {
93055       {
93056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93057       };
93058     } catch (...) {
93059       {
93060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93061       };
93062     }
93063   }
93064   jresult = (void *)result;
93065   return jresult;
93066 }
93067
93068
93069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93071
93072   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93073   {
93074     try {
93075       delete arg1;
93076     } catch (std::out_of_range& e) {
93077       {
93078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93079       };
93080     } catch (std::exception& e) {
93081       {
93082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93083       };
93084     } catch (...) {
93085       {
93086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93087       };
93088     }
93089   }
93090 }
93091
93092
93093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93094   void * jresult ;
93095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93096   Dali::Toolkit::Ruler *result = 0 ;
93097
93098   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93099   {
93100     try {
93101       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93102     } catch (std::out_of_range& e) {
93103       {
93104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93105       };
93106     } catch (std::exception& e) {
93107       {
93108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93109       };
93110     } catch (...) {
93111       {
93112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93113       };
93114     }
93115   }
93116   jresult = (void *)result;
93117   return jresult;
93118 }
93119
93120
93121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93122   void * jresult ;
93123   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93124   Dali::Toolkit::Ruler *result = 0 ;
93125
93126   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93127   {
93128     try {
93129       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93130     } catch (std::out_of_range& e) {
93131       {
93132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93133       };
93134     } catch (std::exception& e) {
93135       {
93136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93137       };
93138     } catch (...) {
93139       {
93140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93141       };
93142     }
93143   }
93144   jresult = (void *)result;
93145   return jresult;
93146 }
93147
93148
93149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93150   void * jresult ;
93151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93152   Dali::Toolkit::Ruler *result = 0 ;
93153
93154   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93155   {
93156     try {
93157       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93158     } catch (std::out_of_range& e) {
93159       {
93160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93161       };
93162     } catch (std::exception& e) {
93163       {
93164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93165       };
93166     } catch (...) {
93167       {
93168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93169       };
93170     }
93171   }
93172   jresult = (void *)result;
93173   return jresult;
93174 }
93175
93176
93177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93178   void * jresult ;
93179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93181   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93182
93183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93184   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93185   if (!arg2) {
93186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93187     return 0;
93188   }
93189   {
93190     try {
93191       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93192     } catch (std::out_of_range& e) {
93193       {
93194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93195       };
93196     } catch (std::exception& e) {
93197       {
93198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93199       };
93200     } catch (...) {
93201       {
93202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93203       };
93204     }
93205   }
93206   jresult = (void *)result;
93207   return jresult;
93208 }
93209
93210
93211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93212   void * jresult ;
93213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93214   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93216
93217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93218   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93219   {
93220     try {
93221       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93222     } catch (std::out_of_range& e) {
93223       {
93224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93225       };
93226     } catch (std::exception& e) {
93227       {
93228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93229       };
93230     } catch (...) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93233       };
93234     }
93235   }
93236   jresult = (void *)result;
93237   return jresult;
93238 }
93239
93240
93241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93242   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93243
93244   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93245   {
93246     try {
93247       (arg1)->Reset();
93248     } catch (std::out_of_range& e) {
93249       {
93250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (std::exception& e) {
93253       {
93254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93259       };
93260     }
93261   }
93262 }
93263
93264
93265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93266   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93267   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93268
93269   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93270   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93271   {
93272     try {
93273       (arg1)->Reset(arg2);
93274     } catch (std::out_of_range& e) {
93275       {
93276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93277       };
93278     } catch (std::exception& e) {
93279       {
93280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93281       };
93282     } catch (...) {
93283       {
93284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93285       };
93286     }
93287   }
93288 }
93289
93290
93291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93292   void * jresult ;
93293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93294   Dali::Toolkit::Ruler *result = 0 ;
93295
93296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93297   {
93298     try {
93299       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93300     } catch (std::out_of_range& e) {
93301       {
93302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93303       };
93304     } catch (std::exception& e) {
93305       {
93306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93307       };
93308     } catch (...) {
93309       {
93310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93311       };
93312     }
93313   }
93314   jresult = (void *)result;
93315   return jresult;
93316 }
93317
93318
93319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93320   float jresult ;
93321   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93322   float arg2 ;
93323   float arg3 ;
93324   float result;
93325
93326   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93327   arg2 = (float)jarg2;
93328   arg3 = (float)jarg3;
93329   {
93330     try {
93331       result = (float)(*arg1)->Snap(arg2,arg3);
93332     } catch (std::out_of_range& e) {
93333       {
93334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93335       };
93336     } catch (std::exception& e) {
93337       {
93338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93339       };
93340     } catch (...) {
93341       {
93342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93343       };
93344     }
93345   }
93346   jresult = result;
93347   return jresult;
93348 }
93349
93350
93351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93352   float jresult ;
93353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93354   float arg2 ;
93355   float result;
93356
93357   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93358   arg2 = (float)jarg2;
93359   {
93360     try {
93361       result = (float)(*arg1)->Snap(arg2);
93362     } catch (std::out_of_range& e) {
93363       {
93364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93365       };
93366     } catch (std::exception& e) {
93367       {
93368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93369       };
93370     } catch (...) {
93371       {
93372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93373       };
93374     }
93375   }
93376   jresult = result;
93377   return jresult;
93378 }
93379
93380
93381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93382   float jresult ;
93383   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93384   unsigned int arg2 ;
93385   unsigned int *arg3 = 0 ;
93386   bool arg4 ;
93387   float result;
93388
93389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93390   arg2 = (unsigned int)jarg2;
93391   arg3 = (unsigned int *)jarg3;
93392   arg4 = jarg4 ? true : false;
93393   {
93394     try {
93395       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93396     } catch (std::out_of_range& e) {
93397       {
93398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93399       };
93400     } catch (std::exception& e) {
93401       {
93402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93403       };
93404     } catch (...) {
93405       {
93406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93407       };
93408     }
93409   }
93410   jresult = result;
93411   return jresult;
93412 }
93413
93414
93415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93416   unsigned int jresult ;
93417   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93418   float arg2 ;
93419   bool arg3 ;
93420   unsigned int result;
93421
93422   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93423   arg2 = (float)jarg2;
93424   arg3 = jarg3 ? true : false;
93425   {
93426     try {
93427       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93428     } catch (std::out_of_range& e) {
93429       {
93430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93431       };
93432     } catch (std::exception& e) {
93433       {
93434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93435       };
93436     } catch (...) {
93437       {
93438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93439       };
93440     }
93441   }
93442   jresult = result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93448   unsigned int jresult ;
93449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93450   unsigned int result;
93451
93452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93453   {
93454     try {
93455       result = (unsigned int)(*arg1)->GetTotalPages();
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (...) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93467       };
93468     }
93469   }
93470   jresult = result;
93471   return jresult;
93472 }
93473
93474
93475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93476   int jresult ;
93477   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93478   Dali::Toolkit::Ruler::RulerType result;
93479
93480   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93481   {
93482     try {
93483       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93484     } catch (std::out_of_range& e) {
93485       {
93486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93487       };
93488     } catch (std::exception& e) {
93489       {
93490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93491       };
93492     } catch (...) {
93493       {
93494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93495       };
93496     }
93497   }
93498   jresult = (int)result;
93499   return jresult;
93500 }
93501
93502
93503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93504   unsigned int jresult ;
93505   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93506   bool result;
93507
93508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93509   {
93510     try {
93511       result = (bool)(*arg1)->IsEnabled();
93512     } catch (std::out_of_range& e) {
93513       {
93514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93515       };
93516     } catch (std::exception& e) {
93517       {
93518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93519       };
93520     } catch (...) {
93521       {
93522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93523       };
93524     }
93525   }
93526   jresult = result;
93527   return jresult;
93528 }
93529
93530
93531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93532   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93533
93534   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93535   {
93536     try {
93537       (*arg1)->Enable();
93538     } catch (std::out_of_range& e) {
93539       {
93540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93541       };
93542     } catch (std::exception& e) {
93543       {
93544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93545       };
93546     } catch (...) {
93547       {
93548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93549       };
93550     }
93551   }
93552 }
93553
93554
93555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93556   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93557
93558   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93559   {
93560     try {
93561       (*arg1)->Disable();
93562     } catch (std::out_of_range& e) {
93563       {
93564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93565       };
93566     } catch (std::exception& e) {
93567       {
93568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93569       };
93570     } catch (...) {
93571       {
93572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93573       };
93574     }
93575   }
93576 }
93577
93578
93579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93580   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93581   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93582   Dali::Toolkit::RulerDomain *argp2 ;
93583
93584   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93585   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93586   if (!argp2) {
93587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93588     return ;
93589   }
93590   arg2 = *argp2;
93591   {
93592     try {
93593       (*arg1)->SetDomain(arg2);
93594     } catch (std::out_of_range& e) {
93595       {
93596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93597       };
93598     } catch (std::exception& e) {
93599       {
93600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93601       };
93602     } catch (...) {
93603       {
93604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93605       };
93606     }
93607   }
93608 }
93609
93610
93611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93612   void * jresult ;
93613   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93614   Dali::Toolkit::RulerDomain *result = 0 ;
93615
93616   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93617   {
93618     try {
93619       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93620     } catch (std::out_of_range& e) {
93621       {
93622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (std::exception& e) {
93625       {
93626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93627       };
93628     } catch (...) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93631       };
93632     }
93633   }
93634   jresult = (void *)result;
93635   return jresult;
93636 }
93637
93638
93639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93640   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93641
93642   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93643   {
93644     try {
93645       (*arg1)->DisableDomain();
93646     } catch (std::out_of_range& e) {
93647       {
93648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93649       };
93650     } catch (std::exception& e) {
93651       {
93652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93653       };
93654     } catch (...) {
93655       {
93656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93657       };
93658     }
93659   }
93660 }
93661
93662
93663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93664   float jresult ;
93665   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93666   float arg2 ;
93667   float arg3 ;
93668   float arg4 ;
93669   float result;
93670
93671   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93672   arg2 = (float)jarg2;
93673   arg3 = (float)jarg3;
93674   arg4 = (float)jarg4;
93675   {
93676     try {
93677       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93678     } catch (std::out_of_range& e) {
93679       {
93680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93681       };
93682     } catch (std::exception& e) {
93683       {
93684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93685       };
93686     } catch (...) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93689       };
93690     }
93691   }
93692   jresult = result;
93693   return jresult;
93694 }
93695
93696
93697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93698   float jresult ;
93699   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93700   float arg2 ;
93701   float arg3 ;
93702   float result;
93703
93704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93705   arg2 = (float)jarg2;
93706   arg3 = (float)jarg3;
93707   {
93708     try {
93709       result = (float)(*arg1)->Clamp(arg2,arg3);
93710     } catch (std::out_of_range& e) {
93711       {
93712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93713       };
93714     } catch (std::exception& e) {
93715       {
93716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93717       };
93718     } catch (...) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93721       };
93722     }
93723   }
93724   jresult = result;
93725   return jresult;
93726 }
93727
93728
93729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93730   float jresult ;
93731   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93732   float arg2 ;
93733   float result;
93734
93735   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93736   arg2 = (float)jarg2;
93737   {
93738     try {
93739       result = (float)(*arg1)->Clamp(arg2);
93740     } catch (std::out_of_range& e) {
93741       {
93742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93743       };
93744     } catch (std::exception& e) {
93745       {
93746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93747       };
93748     } catch (...) {
93749       {
93750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93751       };
93752     }
93753   }
93754   jresult = result;
93755   return jresult;
93756 }
93757
93758
93759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93760   float jresult ;
93761   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93762   float arg2 ;
93763   float arg3 ;
93764   float arg4 ;
93765   Dali::Toolkit::ClampState *arg5 = 0 ;
93766   float result;
93767
93768   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93769   arg2 = (float)jarg2;
93770   arg3 = (float)jarg3;
93771   arg4 = (float)jarg4;
93772   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93773   if (!arg5) {
93774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93775     return 0;
93776   }
93777   {
93778     try {
93779       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93780     } catch (std::out_of_range& e) {
93781       {
93782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93783       };
93784     } catch (std::exception& e) {
93785       {
93786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93787       };
93788     } catch (...) {
93789       {
93790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93791       };
93792     }
93793   }
93794   jresult = result;
93795   return jresult;
93796 }
93797
93798
93799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93800   float jresult ;
93801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93802   float arg2 ;
93803   float arg3 ;
93804   float arg4 ;
93805   float arg5 ;
93806   float result;
93807
93808   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93809   arg2 = (float)jarg2;
93810   arg3 = (float)jarg3;
93811   arg4 = (float)jarg4;
93812   arg5 = (float)jarg5;
93813   {
93814     try {
93815       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93816     } catch (std::out_of_range& e) {
93817       {
93818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93819       };
93820     } catch (std::exception& e) {
93821       {
93822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93823       };
93824     } catch (...) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93827       };
93828     }
93829   }
93830   jresult = result;
93831   return jresult;
93832 }
93833
93834
93835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93836   float jresult ;
93837   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93838   float arg2 ;
93839   float arg3 ;
93840   float arg4 ;
93841   float result;
93842
93843   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93844   arg2 = (float)jarg2;
93845   arg3 = (float)jarg3;
93846   arg4 = (float)jarg4;
93847   {
93848     try {
93849       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93850     } catch (std::out_of_range& e) {
93851       {
93852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93853       };
93854     } catch (std::exception& e) {
93855       {
93856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93857       };
93858     } catch (...) {
93859       {
93860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93861       };
93862     }
93863   }
93864   jresult = result;
93865   return jresult;
93866 }
93867
93868
93869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93870   float jresult ;
93871   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93872   float arg2 ;
93873   float arg3 ;
93874   float result;
93875
93876   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93877   arg2 = (float)jarg2;
93878   arg3 = (float)jarg3;
93879   {
93880     try {
93881       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93882     } catch (std::out_of_range& e) {
93883       {
93884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93885       };
93886     } catch (std::exception& e) {
93887       {
93888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93889       };
93890     } catch (...) {
93891       {
93892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93893       };
93894     }
93895   }
93896   jresult = result;
93897   return jresult;
93898 }
93899
93900
93901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93902   float jresult ;
93903   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93904   float arg2 ;
93905   float result;
93906
93907   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93908   arg2 = (float)jarg2;
93909   {
93910     try {
93911       result = (float)(*arg1)->SnapAndClamp(arg2);
93912     } catch (std::out_of_range& e) {
93913       {
93914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93915       };
93916     } catch (std::exception& e) {
93917       {
93918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93919       };
93920     } catch (...) {
93921       {
93922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93923       };
93924     }
93925   }
93926   jresult = result;
93927   return jresult;
93928 }
93929
93930
93931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93932   float jresult ;
93933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93934   float arg2 ;
93935   float arg3 ;
93936   float arg4 ;
93937   float arg5 ;
93938   Dali::Toolkit::ClampState *arg6 = 0 ;
93939   float result;
93940
93941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93942   arg2 = (float)jarg2;
93943   arg3 = (float)jarg3;
93944   arg4 = (float)jarg4;
93945   arg5 = (float)jarg5;
93946   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93947   if (!arg6) {
93948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93949     return 0;
93950   }
93951   {
93952     try {
93953       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93954     } catch (std::out_of_range& e) {
93955       {
93956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93957       };
93958     } catch (std::exception& e) {
93959       {
93960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93961       };
93962     } catch (...) {
93963       {
93964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93965       };
93966     }
93967   }
93968   jresult = result;
93969   return jresult;
93970 }
93971
93972
93973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93974   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93975
93976   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93977   {
93978     try {
93979       (*arg1)->Reference();
93980     } catch (std::out_of_range& e) {
93981       {
93982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93983       };
93984     } catch (std::exception& e) {
93985       {
93986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93987       };
93988     } catch (...) {
93989       {
93990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93991       };
93992     }
93993   }
93994 }
93995
93996
93997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93999
94000   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94001   {
94002     try {
94003       (*arg1)->Unreference();
94004     } catch (std::out_of_range& e) {
94005       {
94006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94007       };
94008     } catch (std::exception& e) {
94009       {
94010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94011       };
94012     } catch (...) {
94013       {
94014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94015       };
94016     }
94017   }
94018 }
94019
94020
94021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
94022   int jresult ;
94023   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94024   int result;
94025
94026   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94027   {
94028     try {
94029       result = (int)(*arg1)->ReferenceCount();
94030     } catch (std::out_of_range& e) {
94031       {
94032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94033       };
94034     } catch (std::exception& e) {
94035       {
94036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94037       };
94038     } catch (...) {
94039       {
94040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94041       };
94042     }
94043   }
94044   jresult = result;
94045   return jresult;
94046 }
94047
94048
94049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94050   unsigned int jresult ;
94051   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94052   bool result;
94053
94054   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94055   {
94056     try {
94057       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94058     } catch (std::out_of_range& e) {
94059       {
94060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94061       };
94062     } catch (std::exception& e) {
94063       {
94064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94065       };
94066     } catch (...) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94069       };
94070     }
94071   }
94072   jresult = result;
94073   return jresult;
94074 }
94075
94076
94077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94078   unsigned long jresult ;
94079   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94080   std::size_t result;
94081
94082   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94083   {
94084     try {
94085       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94086     } catch (std::out_of_range& e) {
94087       {
94088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94089       };
94090     } catch (std::exception& e) {
94091       {
94092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94093       };
94094     } catch (...) {
94095       {
94096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94097       };
94098     }
94099   }
94100   jresult = (unsigned long)result;
94101   return jresult;
94102 }
94103
94104
94105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
94106   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94107   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94108
94109   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94110   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94111   {
94112     try {
94113       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94114     } catch (std::out_of_range& e) {
94115       {
94116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94117       };
94118     } catch (std::exception& e) {
94119       {
94120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94121       };
94122     } catch (...) {
94123       {
94124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94125       };
94126     }
94127   }
94128 }
94129
94130
94131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
94132   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94133   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94134
94135   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94136   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94137   {
94138     try {
94139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94140     } catch (std::out_of_range& e) {
94141       {
94142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94143       };
94144     } catch (std::exception& e) {
94145       {
94146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94147       };
94148     } catch (...) {
94149       {
94150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94151       };
94152     }
94153   }
94154 }
94155
94156
94157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
94158   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94159   Dali::Toolkit::Control arg2 ;
94160   Dali::Toolkit::Control *argp2 ;
94161
94162   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94163   argp2 = (Dali::Toolkit::Control *)jarg2;
94164   if (!argp2) {
94165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94166     return ;
94167   }
94168   arg2 = *argp2;
94169   {
94170     try {
94171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94172     } catch (std::out_of_range& e) {
94173       {
94174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94175       };
94176     } catch (std::exception& e) {
94177       {
94178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94179       };
94180     } catch (...) {
94181       {
94182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94183       };
94184     }
94185   }
94186 }
94187
94188
94189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94190   void * jresult ;
94191   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94192
94193   {
94194     try {
94195       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94196     } catch (std::out_of_range& e) {
94197       {
94198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94199       };
94200     } catch (std::exception& e) {
94201       {
94202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94203       };
94204     } catch (...) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94207       };
94208     }
94209   }
94210   jresult = (void *)result;
94211   return jresult;
94212 }
94213
94214
94215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94216   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94217
94218   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94219   {
94220     try {
94221       delete arg1;
94222     } catch (std::out_of_range& e) {
94223       {
94224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94225       };
94226     } catch (std::exception& e) {
94227       {
94228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94229       };
94230     } catch (...) {
94231       {
94232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94233       };
94234     }
94235   }
94236 }
94237
94238 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
94239   Dali::RefObject *result = NULL;
94240
94241   if (arg1)
94242   {
94243     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
94244   }
94245   return result;
94246 }
94247
94248 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94249     return (Dali::RefObject *)jarg1;
94250 }
94251
94252 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94253     return (Dali::SignalObserver *)jarg1;
94254 }
94255
94256 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94257     return (Dali::ConnectionTrackerInterface *)jarg1;
94258 }
94259
94260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94261     return (Dali::BaseHandle *)jarg1;
94262 }
94263
94264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94265     return (Dali::BaseHandle *)jarg1;
94266 }
94267
94268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94269     return (Dali::BaseHandle *)jarg1;
94270 }
94271
94272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94273     return (Dali::BaseHandle *)jarg1;
94274 }
94275
94276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94277     return (Dali::BaseHandle *)jarg1;
94278 }
94279
94280 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94281     return (Dali::BaseHandle *)jarg1;
94282 }
94283
94284 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94285     return (Dali::BaseHandle *)jarg1;
94286 }
94287
94288 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94289     return (Dali::BaseHandle *)jarg1;
94290 }
94291
94292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94293     return (Dali::BaseHandle *)jarg1;
94294 }
94295
94296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94297     return (Dali::BaseHandle *)jarg1;
94298 }
94299
94300 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94301     return (Dali::BaseHandle *)jarg1;
94302 }
94303
94304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94305     return (Dali::BaseHandle *)jarg1;
94306 }
94307
94308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94309     return (Dali::BaseHandle *)jarg1;
94310 }
94311
94312 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94313     return (Dali::Handle *)jarg1;
94314 }
94315
94316 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94317     return (Dali::Handle *)jarg1;
94318 }
94319
94320 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94321     return (Dali::BaseHandle *)jarg1;
94322 }
94323
94324 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94325     return (Dali::BaseHandle *)jarg1;
94326 }
94327
94328 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94329     return (Dali::Handle *)jarg1;
94330 }
94331
94332 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94333     return (Dali::BaseHandle *)jarg1;
94334 }
94335
94336 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94337     return (Dali::Handle *)jarg1;
94338 }
94339
94340 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94341     return (Dali::GestureDetector *)jarg1;
94342 }
94343
94344 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94345     return (Dali::Gesture *)jarg1;
94346 }
94347
94348 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94349     return (Dali::Handle *)jarg1;
94350 }
94351
94352 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94353     return (Dali::Actor *)jarg1;
94354 }
94355
94356 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94357     return (Dali::BaseHandle *)jarg1;
94358 }
94359
94360 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94361     return (Dali::RefObject *)jarg1;
94362 }
94363
94364 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94365     return (Dali::Actor *)jarg1;
94366 }
94367
94368 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94369     return (Dali::GestureDetector *)jarg1;
94370 }
94371
94372 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94373     return (Dali::Gesture *)jarg1;
94374 }
94375
94376 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94377     return (Dali::GestureDetector *)jarg1;
94378 }
94379
94380 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94381     return (Dali::Gesture *)jarg1;
94382 }
94383
94384 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94385     return (Dali::GestureDetector *)jarg1;
94386 }
94387
94388 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94389     return (Dali::Gesture *)jarg1;
94390 }
94391
94392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94393     return (Dali::BaseHandle *)jarg1;
94394 }
94395
94396 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94397     return (Dali::Handle *)jarg1;
94398 }
94399
94400 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94401     return (Dali::BaseHandle *)jarg1;
94402 }
94403
94404 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94405     return (Dali::Handle *)jarg1;
94406 }
94407
94408 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94409     return (Dali::Handle *)jarg1;
94410 }
94411
94412 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94413     return (Dali::Image *)jarg1;
94414 }
94415
94416 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94417     return (Dali::Image *)jarg1;
94418 }
94419
94420 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94421     return (Dali::Image *)jarg1;
94422 }
94423
94424 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94425     return (Dali::RefObject *)jarg1;
94426 }
94427
94428 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94429     return (Dali::Image *)jarg1;
94430 }
94431
94432 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94433     return (Dali::Image *)jarg1;
94434 }
94435
94436 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94437     return (Dali::ResourceImage *)jarg1;
94438 }
94439
94440 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94441     return (Dali::Actor *)jarg1;
94442 }
94443
94444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94445     return (Dali::BaseHandle *)jarg1;
94446 }
94447
94448 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94449     return (Dali::BaseHandle *)jarg1;
94450 }
94451
94452 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94453     return (Dali::BaseHandle *)jarg1;
94454 }
94455
94456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94457     return (Dali::BaseHandle *)jarg1;
94458 }
94459
94460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94461     return (Dali::BaseHandle *)jarg1;
94462 }
94463
94464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94465     return (Dali::BaseHandle *)jarg1;
94466 }
94467
94468 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94469     return (Dali::CustomActorImpl *)jarg1;
94470 }
94471
94472 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94473     return (Dali::CustomActor *)jarg1;
94474 }
94475
94476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94477     return (Dali::BaseHandle *)jarg1;
94478 }
94479
94480 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94481     return (Dali::Toolkit::Control *)jarg1;
94482 }
94483
94484 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94485     return (Dali::Toolkit::Control *)jarg1;
94486 }
94487
94488 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94489     return (Dali::Toolkit::Button *)jarg1;
94490 }
94491
94492 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94493     return (Dali::Toolkit::Button *)jarg1;
94494 }
94495
94496 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94497     return (Dali::Toolkit::Button *)jarg1;
94498 }
94499
94500 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94501     return (Dali::Toolkit::Control *)jarg1;
94502 }
94503
94504 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94505     return (Dali::Toolkit::Control *)jarg1;
94506 }
94507
94508 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94509     return (Dali::Toolkit::Control *)jarg1;
94510 }
94511
94512 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94513     return (Dali::Toolkit::Control *)jarg1;
94514 }
94515
94516 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94517     return (Dali::Toolkit::Control *)jarg1;
94518 }
94519
94520 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94521     return (Dali::RefObject *)jarg1;
94522 }
94523
94524 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94525     return (Dali::Toolkit::Scrollable *)jarg1;
94526 }
94527
94528 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94529     return (Dali::BaseHandle *)jarg1;
94530 }
94531
94532 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94533     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94534 }
94535
94536 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94537     return (Dali::RefObject *)jarg1;
94538 }
94539
94540 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94541     return (Dali::Toolkit::Ruler *)jarg1;
94542 }
94543
94544 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94545     return (Dali::Toolkit::Ruler *)jarg1;
94546 }
94547
94548 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94549     return (Dali::Toolkit::Scrollable *)jarg1;
94550 }
94551
94552 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94553     return (Dali::Toolkit::Control *)jarg1;
94554 }
94555
94556 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94557     return (Dali::Toolkit::Control *)jarg1;
94558 }
94559
94560 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94561     return (Dali::Toolkit::Control *)jarg1;
94562 }
94563
94564 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94565     return (Dali::Toolkit::Control *)jarg1;
94566 }
94567
94568 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94569     return (Dali::BaseHandle *)jarg1;
94570 }
94571
94572 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94573     return (Dali::BaseHandle *)jarg1;
94574 }
94575
94576 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94577     return (Dali::Toolkit::Control *)jarg1;
94578 }
94579
94580 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94581     return (Dali::Toolkit::Control *)jarg1;
94582 }
94583
94584 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94585     return (Dali::Toolkit::Control *)jarg1;
94586 }
94587
94588 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94589     return (Dali::Toolkit::Control *)jarg1;
94590 }
94591
94592 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94593     return (Dali::Toolkit::Control *)jarg1;
94594 }
94595
94596 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94597     return (Dali::Toolkit::Control *)jarg1;
94598 }
94599
94600 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94601     return (Dali::Toolkit::PageTurnView *)jarg1;
94602 }
94603
94604 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94605     return (Dali::Toolkit::PageTurnView *)jarg1;
94606 }
94607
94608 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94609     return (Dali::Toolkit::Button *)jarg1;
94610 }
94611
94612 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94613     return (Dali::BaseHandle *)jarg1;
94614 }
94615
94616 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94617     return (Dali::BaseHandle *)jarg1;
94618 }
94619
94620 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94621     return (Dali::BaseHandle *)jarg1;
94622 }
94623
94624
94625
94626
94627
94628 //////////////////////////////////////////////////
94629 //from dali-swig autogeneration (from dali_wrap.cpp)
94630
94631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94632   void * jresult ;
94633   Dali::ImfManager::ImfEventData *result = 0 ;
94634
94635   {
94636     try {
94637       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94638     } catch (std::out_of_range& e) {
94639       {
94640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94641       };
94642     } catch (std::exception& e) {
94643       {
94644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94645       };
94646     } catch (...) {
94647       {
94648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94649       };
94650     }
94651   }
94652   jresult = (void *)result;
94653   return jresult;
94654 }
94655
94656
94657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94658   void * jresult ;
94659   Dali::ImfManager::ImfEvent arg1 ;
94660   std::string *arg2 = 0 ;
94661   int arg3 ;
94662   int arg4 ;
94663   Dali::ImfManager::ImfEventData *result = 0 ;
94664
94665   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94666   if (!jarg2) {
94667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94668     return 0;
94669   }
94670   std::string arg2_str(jarg2);
94671   arg2 = &arg2_str;
94672   arg3 = (int)jarg3;
94673   arg4 = (int)jarg4;
94674   {
94675     try {
94676       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94677     } catch (std::out_of_range& e) {
94678       {
94679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94680       };
94681     } catch (std::exception& e) {
94682       {
94683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (...) {
94686       {
94687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94688       };
94689     }
94690   }
94691   jresult = (void *)result;
94692
94693   //argout typemap for const std::string&
94694
94695   return jresult;
94696 }
94697
94698
94699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94700   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94701   std::string *arg2 = 0 ;
94702
94703   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94704   if (!jarg2) {
94705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94706     return ;
94707   }
94708   std::string arg2_str(jarg2);
94709   arg2 = &arg2_str;
94710   if (arg1) (arg1)->predictiveString = *arg2;
94711
94712   //argout typemap for const std::string&
94713
94714 }
94715
94716
94717 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94718   char * jresult ;
94719   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94720   std::string *result = 0 ;
94721
94722   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94723   result = (std::string *) & ((arg1)->predictiveString);
94724   jresult = SWIG_csharp_string_callback(result->c_str());
94725   return jresult;
94726 }
94727
94728
94729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94730   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94731   Dali::ImfManager::ImfEvent arg2 ;
94732
94733   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94734   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94735   if (arg1) (arg1)->eventName = arg2;
94736 }
94737
94738
94739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94740   int jresult ;
94741   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94742   Dali::ImfManager::ImfEvent result;
94743
94744   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94745   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94746   jresult = (int)result;
94747   return jresult;
94748 }
94749
94750
94751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94752   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94753   int arg2 ;
94754
94755   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94756   arg2 = (int)jarg2;
94757   if (arg1) (arg1)->cursorOffset = arg2;
94758 }
94759
94760
94761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94762   int jresult ;
94763   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94764   int result;
94765
94766   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94767   result = (int) ((arg1)->cursorOffset);
94768   jresult = result;
94769   return jresult;
94770 }
94771
94772
94773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94774   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94775   int arg2 ;
94776
94777   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94778   arg2 = (int)jarg2;
94779   if (arg1) (arg1)->numberOfChars = arg2;
94780 }
94781
94782
94783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94784   int jresult ;
94785   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94786   int result;
94787
94788   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94789   result = (int) ((arg1)->numberOfChars);
94790   jresult = result;
94791   return jresult;
94792 }
94793
94794
94795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94796   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94797
94798   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94799   {
94800     try {
94801       delete arg1;
94802     } catch (std::out_of_range& e) {
94803       {
94804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94805       };
94806     } catch (std::exception& e) {
94807       {
94808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94809       };
94810     } catch (...) {
94811       {
94812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94813       };
94814     }
94815   }
94816 }
94817
94818
94819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94820   void * jresult ;
94821   Dali::ImfManager::ImfCallbackData *result = 0 ;
94822
94823   {
94824     try {
94825       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94833       };
94834     } catch (...) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94837       };
94838     }
94839   }
94840   jresult = (void *)result;
94841   return jresult;
94842 }
94843
94844
94845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94846   void * jresult ;
94847   bool arg1 ;
94848   int arg2 ;
94849   std::string *arg3 = 0 ;
94850   bool arg4 ;
94851   Dali::ImfManager::ImfCallbackData *result = 0 ;
94852
94853   arg1 = jarg1 ? true : false;
94854   arg2 = (int)jarg2;
94855   if (!jarg3) {
94856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94857     return 0;
94858   }
94859   std::string arg3_str(jarg3);
94860   arg3 = &arg3_str;
94861   arg4 = jarg4 ? true : false;
94862   {
94863     try {
94864       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94865     } catch (std::out_of_range& e) {
94866       {
94867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94868       };
94869     } catch (std::exception& e) {
94870       {
94871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94872       };
94873     } catch (...) {
94874       {
94875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94876       };
94877     }
94878   }
94879   jresult = (void *)result;
94880
94881   //argout typemap for const std::string&
94882
94883   return jresult;
94884 }
94885
94886
94887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94888   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94889   std::string *arg2 = 0 ;
94890
94891   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94892   if (!jarg2) {
94893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94894     return ;
94895   }
94896   std::string arg2_str(jarg2);
94897   arg2 = &arg2_str;
94898   if (arg1) (arg1)->currentText = *arg2;
94899
94900   //argout typemap for const std::string&
94901
94902 }
94903
94904
94905 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94906   char * jresult ;
94907   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94908   std::string *result = 0 ;
94909
94910   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94911   result = (std::string *) & ((arg1)->currentText);
94912   jresult = SWIG_csharp_string_callback(result->c_str());
94913   return jresult;
94914 }
94915
94916
94917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94918   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94919   int arg2 ;
94920
94921   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94922   arg2 = (int)jarg2;
94923   if (arg1) (arg1)->cursorPosition = arg2;
94924 }
94925
94926
94927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94928   int jresult ;
94929   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94930   int result;
94931
94932   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94933   result = (int) ((arg1)->cursorPosition);
94934   jresult = result;
94935   return jresult;
94936 }
94937
94938
94939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94940   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94941   bool arg2 ;
94942
94943   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94944   arg2 = jarg2 ? true : false;
94945   if (arg1) (arg1)->update = arg2;
94946 }
94947
94948
94949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94950   unsigned int jresult ;
94951   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94952   bool result;
94953
94954   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94955   result = (bool) ((arg1)->update);
94956   jresult = result;
94957   return jresult;
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94962   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94963   bool arg2 ;
94964
94965   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94966   arg2 = jarg2 ? true : false;
94967   if (arg1) (arg1)->preeditResetRequired = arg2;
94968 }
94969
94970
94971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94972   unsigned int jresult ;
94973   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94974   bool result;
94975
94976   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94977   result = (bool) ((arg1)->preeditResetRequired);
94978   jresult = result;
94979   return jresult;
94980 }
94981
94982
94983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94984   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94985
94986   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94987   {
94988     try {
94989       delete arg1;
94990     } catch (std::out_of_range& e) {
94991       {
94992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94993       };
94994     } catch (std::exception& e) {
94995       {
94996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94997       };
94998     } catch (...) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95001       };
95002     }
95003   }
95004 }
95005
95006
95007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
95008   void * jresult ;
95009   Dali::ImfManager result;
95010
95011   {
95012     try {
95013       result = Dali::ImfManager::Get();
95014     } catch (std::out_of_range& e) {
95015       {
95016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95017       };
95018     } catch (std::exception& e) {
95019       {
95020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95021       };
95022     } catch (...) {
95023       {
95024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95025       };
95026     }
95027   }
95028   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
95029   return jresult;
95030 }
95031
95032
95033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
95034   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95035
95036   arg1 = (Dali::ImfManager *)jarg1;
95037   {
95038     try {
95039       (arg1)->Activate();
95040     } catch (std::out_of_range& e) {
95041       {
95042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95043       };
95044     } catch (std::exception& e) {
95045       {
95046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95047       };
95048     } catch (...) {
95049       {
95050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95051       };
95052     }
95053   }
95054 }
95055
95056
95057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
95058   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95059
95060   arg1 = (Dali::ImfManager *)jarg1;
95061   {
95062     try {
95063       (arg1)->Deactivate();
95064     } catch (std::out_of_range& e) {
95065       {
95066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95067       };
95068     } catch (std::exception& e) {
95069       {
95070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95071       };
95072     } catch (...) {
95073       {
95074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95075       };
95076     }
95077   }
95078 }
95079
95080
95081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
95082   unsigned int jresult ;
95083   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95084   bool result;
95085
95086   arg1 = (Dali::ImfManager *)jarg1;
95087   {
95088     try {
95089       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
95090     } catch (std::out_of_range& e) {
95091       {
95092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95093       };
95094     } catch (std::exception& e) {
95095       {
95096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95097       };
95098     } catch (...) {
95099       {
95100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95101       };
95102     }
95103   }
95104   jresult = result;
95105   return jresult;
95106 }
95107
95108
95109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
95110   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95111   bool arg2 ;
95112
95113   arg1 = (Dali::ImfManager *)jarg1;
95114   arg2 = jarg2 ? true : false;
95115   {
95116     try {
95117       (arg1)->SetRestoreAfterFocusLost(arg2);
95118     } catch (std::out_of_range& e) {
95119       {
95120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95121       };
95122     } catch (std::exception& e) {
95123       {
95124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95125       };
95126     } catch (...) {
95127       {
95128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95129       };
95130     }
95131   }
95132 }
95133
95134
95135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
95136   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95137
95138   arg1 = (Dali::ImfManager *)jarg1;
95139   {
95140     try {
95141       (arg1)->Reset();
95142     } catch (std::out_of_range& e) {
95143       {
95144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95145       };
95146     } catch (std::exception& e) {
95147       {
95148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95149       };
95150     } catch (...) {
95151       {
95152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95153       };
95154     }
95155   }
95156 }
95157
95158
95159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
95160   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95161
95162   arg1 = (Dali::ImfManager *)jarg1;
95163   {
95164     try {
95165       (arg1)->NotifyCursorPosition();
95166     } catch (std::out_of_range& e) {
95167       {
95168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95169       };
95170     } catch (std::exception& e) {
95171       {
95172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95173       };
95174     } catch (...) {
95175       {
95176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95177       };
95178     }
95179   }
95180 }
95181
95182
95183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95184   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95185   unsigned int arg2 ;
95186
95187   arg1 = (Dali::ImfManager *)jarg1;
95188   arg2 = (unsigned int)jarg2;
95189   {
95190     try {
95191       (arg1)->SetCursorPosition(arg2);
95192     } catch (std::out_of_range& e) {
95193       {
95194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95195       };
95196     } catch (std::exception& e) {
95197       {
95198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95199       };
95200     } catch (...) {
95201       {
95202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95203       };
95204     }
95205   }
95206 }
95207
95208
95209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95210   unsigned int jresult ;
95211   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95212   unsigned int result;
95213
95214   arg1 = (Dali::ImfManager *)jarg1;
95215   {
95216     try {
95217       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95218     } catch (std::out_of_range& e) {
95219       {
95220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (std::exception& e) {
95223       {
95224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95225       };
95226     } catch (...) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95229       };
95230     }
95231   }
95232   jresult = result;
95233   return jresult;
95234 }
95235
95236
95237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95238   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95239   std::string *arg2 = 0 ;
95240
95241   arg1 = (Dali::ImfManager *)jarg1;
95242   if (!jarg2) {
95243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95244     return ;
95245   }
95246   std::string arg2_str(jarg2);
95247   arg2 = &arg2_str;
95248   {
95249     try {
95250       (arg1)->SetSurroundingText((std::string const &)*arg2);
95251     } catch (std::out_of_range& e) {
95252       {
95253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95254       };
95255     } catch (std::exception& e) {
95256       {
95257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95258       };
95259     } catch (...) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95262       };
95263     }
95264   }
95265
95266   //argout typemap for const std::string&
95267
95268 }
95269
95270
95271 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95272   char * jresult ;
95273   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95274   std::string *result = 0 ;
95275
95276   arg1 = (Dali::ImfManager *)jarg1;
95277   {
95278     try {
95279       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95280     } catch (std::out_of_range& e) {
95281       {
95282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95283       };
95284     } catch (std::exception& e) {
95285       {
95286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95287       };
95288     } catch (...) {
95289       {
95290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95291       };
95292     }
95293   }
95294   jresult = SWIG_csharp_string_callback(result->c_str());
95295   return jresult;
95296 }
95297
95298
95299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95300   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95301   bool arg2 ;
95302
95303   arg1 = (Dali::ImfManager *)jarg1;
95304   arg2 = jarg2 ? true : false;
95305   {
95306     try {
95307       (arg1)->NotifyTextInputMultiLine(arg2);
95308     } catch (std::out_of_range& e) {
95309       {
95310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95311       };
95312     } catch (std::exception& e) {
95313       {
95314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95315       };
95316     } catch (...) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95319       };
95320     }
95321   }
95322 }
95323
95324
95325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95326   int jresult ;
95327   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95328   Dali::ImfManager::TextDirection result;
95329
95330   arg1 = (Dali::ImfManager *)jarg1;
95331   {
95332     try {
95333       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95334     } catch (std::out_of_range& e) {
95335       {
95336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95337       };
95338     } catch (std::exception& e) {
95339       {
95340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95341       };
95342     } catch (...) {
95343       {
95344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95345       };
95346     }
95347   }
95348   jresult = (int)result;
95349   return jresult;
95350 }
95351
95352
95353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95354   void * jresult ;
95355   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95356   Dali::Rect< int > result;
95357
95358   arg1 = (Dali::ImfManager *)jarg1;
95359   {
95360     try {
95361       result = (arg1)->GetInputMethodArea();
95362     } catch (std::out_of_range& e) {
95363       {
95364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95365       };
95366     } catch (std::exception& e) {
95367       {
95368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95369       };
95370     } catch (...) {
95371       {
95372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95373       };
95374     }
95375   }
95376   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95377   return jresult;
95378 }
95379
95380
95381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95382   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95383   Dali::InputMethodOptions *arg2 = 0 ;
95384
95385   arg1 = (Dali::ImfManager *)jarg1;
95386   arg2 = (Dali::InputMethodOptions *)jarg2;
95387   if (!arg2) {
95388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95389     return ;
95390   }
95391   {
95392     try {
95393       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95394     } catch (std::out_of_range& e) {
95395       {
95396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95397       };
95398     } catch (std::exception& e) {
95399       {
95400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95401       };
95402     } catch (...) {
95403       {
95404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95405       };
95406     }
95407   }
95408 }
95409
95410
95411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95412   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95413   std::string *arg2 = 0 ;
95414
95415   arg1 = (Dali::ImfManager *)jarg1;
95416   if (!jarg2) {
95417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95418     return ;
95419   }
95420   std::string arg2_str(jarg2);
95421   arg2 = &arg2_str;
95422   {
95423     try {
95424       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95425     } catch (std::out_of_range& e) {
95426       {
95427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95428       };
95429     } catch (std::exception& e) {
95430       {
95431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95432       };
95433     } catch (...) {
95434       {
95435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95436       };
95437     }
95438   }
95439
95440   //argout typemap for const std::string&
95441
95442 }
95443
95444
95445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95446   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95447   std::string *arg2 = 0 ;
95448
95449   arg1 = (Dali::ImfManager *)jarg1;
95450   if (!jarg2) {
95451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95452     return ;
95453   }
95454   std::string arg2_str(jarg2);
95455   arg2 = &arg2_str;
95456   {
95457     try {
95458       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95459     } catch (std::out_of_range& e) {
95460       {
95461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95462       };
95463     } catch (std::exception& e) {
95464       {
95465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95466       };
95467     } catch (...) {
95468       {
95469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95470       };
95471     }
95472   }
95473
95474 }
95475
95476
95477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95478   int jresult ;
95479   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95480   Dali::ImfManager::State result;
95481
95482   arg1 = (Dali::ImfManager *)jarg1;
95483   {
95484     try {
95485       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95486     } catch (std::out_of_range& e) {
95487       {
95488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95489       };
95490     } catch (std::exception& e) {
95491       {
95492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95493       };
95494     } catch (...) {
95495       {
95496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95497       };
95498     }
95499   }
95500   jresult = (int)result;
95501   return jresult;
95502 }
95503
95504
95505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95506   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95507   bool arg2 ;
95508
95509   arg1 = (Dali::ImfManager *)jarg1;
95510   arg2 = jarg2 ? true : false;
95511   {
95512     try {
95513       (arg1)->SetReturnKeyState(arg2);
95514     } catch (std::out_of_range& e) {
95515       {
95516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95517       };
95518     } catch (std::exception& e) {
95519       {
95520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95521       };
95522     } catch (...) {
95523       {
95524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95525       };
95526     }
95527   }
95528 }
95529
95530
95531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95532   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95533   bool arg2 ;
95534
95535   arg1 = (Dali::ImfManager *)jarg1;
95536   arg2 = jarg2 ? true : false;
95537   {
95538     try {
95539       (arg1)->AutoEnableInputPanel(arg2);
95540     } catch (std::out_of_range& e) {
95541       {
95542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95543       };
95544     } catch (std::exception& e) {
95545       {
95546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95547       };
95548     } catch (...) {
95549       {
95550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95551       };
95552     }
95553   }
95554 }
95555
95556
95557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95558   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95559
95560   arg1 = (Dali::ImfManager *)jarg1;
95561   {
95562     try {
95563       (arg1)->ShowInputPanel();
95564     } catch (std::out_of_range& e) {
95565       {
95566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95567       };
95568     } catch (std::exception& e) {
95569       {
95570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95571       };
95572     } catch (...) {
95573       {
95574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95575       };
95576     }
95577   }
95578 }
95579
95580
95581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95582   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95583
95584   arg1 = (Dali::ImfManager *)jarg1;
95585   {
95586     try {
95587       (arg1)->HideInputPanel();
95588     } catch (std::out_of_range& e) {
95589       {
95590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95591       };
95592     } catch (std::exception& e) {
95593       {
95594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95595       };
95596     } catch (...) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95599       };
95600     }
95601   }
95602 }
95603
95604
95605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95606   void * jresult ;
95607   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95608   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95609
95610   arg1 = (Dali::ImfManager *)jarg1;
95611   {
95612     try {
95613       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95614     } catch (std::out_of_range& e) {
95615       {
95616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95617       };
95618     } catch (std::exception& e) {
95619       {
95620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95621       };
95622     } catch (...) {
95623       {
95624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95625       };
95626     }
95627   }
95628   jresult = (void *)result;
95629   return jresult;
95630 }
95631
95632
95633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95634   void * jresult ;
95635   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95636   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95637
95638   arg1 = (Dali::ImfManager *)jarg1;
95639   {
95640     try {
95641       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95642     } catch (std::out_of_range& e) {
95643       {
95644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95645       };
95646     } catch (std::exception& e) {
95647       {
95648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95649       };
95650     } catch (...) {
95651       {
95652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95653       };
95654     }
95655   }
95656   jresult = (void *)result;
95657   return jresult;
95658 }
95659
95660
95661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95662   void * jresult ;
95663   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95664   Dali::ImfManager::StatusSignalType *result = 0 ;
95665
95666   arg1 = (Dali::ImfManager *)jarg1;
95667   {
95668     try {
95669       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95670     } catch (std::out_of_range& e) {
95671       {
95672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95673       };
95674     } catch (std::exception& e) {
95675       {
95676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95677       };
95678     } catch (...) {
95679       {
95680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95681       };
95682     }
95683   }
95684   jresult = (void *)result;
95685   return jresult;
95686 }
95687
95688
95689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95690   void * jresult ;
95691   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95692   Dali::ImfManager::VoidSignalType *result = 0 ;
95693
95694   arg1 = (Dali::ImfManager *)jarg1;
95695   {
95696     try {
95697       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95698     } catch (std::out_of_range& e) {
95699       {
95700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95701       };
95702     } catch (std::exception& e) {
95703       {
95704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95705       };
95706     } catch (...) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95709       };
95710     }
95711   }
95712   jresult = (void *)result;
95713   return jresult;
95714 }
95715
95716
95717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95718   void * jresult ;
95719   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95720   Dali::ImfManager::VoidSignalType *result = 0 ;
95721
95722   arg1 = (Dali::ImfManager *)jarg1;
95723   {
95724     try {
95725       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95726     } catch (std::out_of_range& e) {
95727       {
95728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95729       };
95730     } catch (std::exception& e) {
95731       {
95732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95733       };
95734     } catch (...) {
95735       {
95736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95737       };
95738     }
95739   }
95740   jresult = (void *)result;
95741   return jresult;
95742 }
95743
95744
95745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95746   void * jresult ;
95747   Dali::ImfManager *result = 0 ;
95748
95749   {
95750     try {
95751       result = (Dali::ImfManager *)new Dali::ImfManager();
95752     } catch (std::out_of_range& e) {
95753       {
95754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95755       };
95756     } catch (std::exception& e) {
95757       {
95758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95759       };
95760     } catch (...) {
95761       {
95762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95763       };
95764     }
95765   }
95766   jresult = (void *)result;
95767   return jresult;
95768 }
95769
95770
95771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95772   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95773
95774   arg1 = (Dali::ImfManager *)jarg1;
95775   {
95776     try {
95777       delete arg1;
95778     } catch (std::out_of_range& e) {
95779       {
95780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95781       };
95782     } catch (std::exception& e) {
95783       {
95784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95785       };
95786     } catch (...) {
95787       {
95788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95789       };
95790     }
95791   }
95792 }
95793
95794
95795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95796   void * jresult ;
95797   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95798   Dali::ImfManager *result = 0 ;
95799
95800   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95801   {
95802     try {
95803       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95804     } catch (std::out_of_range& e) {
95805       {
95806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95807       };
95808     } catch (std::exception& e) {
95809       {
95810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95811       };
95812     } catch (...) {
95813       {
95814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95815       };
95816     }
95817   }
95818   jresult = (void *)result;
95819   return jresult;
95820 }
95821
95822
95823 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95824     return (Dali::BaseHandle *)jarg1;
95825 }
95826
95827
95828 //////////////////////////////////////////////////
95829 //from dali-swig autogeneration (from dali_wrap.cpp)
95830
95831
95832
95833
95834
95835
95836
95837
95838
95839
95840
95841
95842 #ifdef __cplusplus
95843 }
95844 #endif